mirror of
https://github.com/Termix-SSH/Termix.git
synced 2026-10-30 15:15:24 +00:00
v26.10.6 (#1739)
* feat: let the login page send the token back to the mobile app * feat: add host-scripts entry to the plugin sdk * feat: let plugins say how they show in the mobile app * feat: frame host for running one plugin view outside the shell * fix: build the SDK host modules in production mode * chore: note the SDK host build fix in the changelog * feat: list plugin engine ranges for the mobile app * feat: host color and icon columns that sync * chore: update translations and plugin pins * fix: test * fix: show source address when rejecting proxy auth * fix: deleting your own account removes all of its data * fix(deps): update body-parser to 2.4.0 (#1736) * fix: body-parser 보안 패치 반영 * chore: 자동 검사를 막던 기존 JSON 서식 정리 --------- Co-authored-by: renovys <180682734+renovys@users.noreply.github.com> * fix(sdk): decode command output as GBK when it is not valid UTF-8 (#1735) * fix: honor shared credentials on shared hosts (#1730) * fix: honor shared credentials on shared hosts and in personal SSH auth * fix: snapshot shared SSH auth from a credential shared with the host owner * fix: size DataView list columns by the table's own width (#1713) * fix: size DataView list columns by the table's own width The list grid was built from every column, so columns hidden below md/lg left empty tracks and the visible cells landed under the wrong headers. Each width now gets a template of only its visible columns (CSS variables + container queries on the table, so a narrow panel counts, not the window), the header uses the same gap as the rows, and rows use a minimum height so wrapped cells no longer overlap. * test: wait for the title bar offset effect before asserting The bar shows once getTitleBarVisible resolves, but --termix-titlebar-height is set in a later passive effect, so reading it right after findByText raced (3-5 of 40 runs under load, on main too). * chore: rerun CI against dev-26.10.6 * fix: unlock passphrase keys once per connect burst (#1737) * feat: give ssh transports the host origin and sync id (#1717) * fix: wake other clients after a sync push (Plugin-Sync#1) * feat: look up local row ids by sync id for the sync plugin (Plugin-Sync#4) * feat: rail items can show a status dot (Plugin-Sync#5) * fix: add the desktop shared copy banner text (#1709) * feat: sidebar preference for alternating rows (#1712) * fix: striped rows text * feat: shell can open a saved host's editor for plugins (Plugin-SSH-Terminal#36) * fix: show the logo in the macos menu bar (#1728) * fix: number shortcuts skip the home tab (#1724) * fix: show plugins that could not be downloaded as failed (#1714) * fix: pass the host id as text when opening its editor * fix: retry a plugin bundle that was not ready yet (#1708) * fix: let commonjs plugins fall back to core packages on the desktop * fix: let non docker installs switch nginx to https (#1711) * feat: remove a folder share from its hosts too (#1719) * chore: changelog for merged pull requests * fix: accept the release .sig when installing a plugin from a file * feat: folder logins for shared hosts, read only plugin sync, full desktop builds * fix: test * fix: stop dev runner restart loops and narrow plugin watchers * chore: update translations and plugin pins * chore: lint, format, and bump version to 26.10.6 --------- Co-authored-by: renovys <renovy@gmail.com> Co-authored-by: renovys <180682734+renovys@users.noreply.github.com> Co-authored-by: Sebastian Cao <cycsmail@gmail.com> Co-authored-by: Jonathan Rehuel Lewerissa <jonathan.rehuel16@gmail.com> Co-authored-by: Rhiz3K <33246262+Rhiz3K@users.noreply.github.com>
This commit is contained in:
168 files changed
+35063
-339
No files matched your search
@@ -1,5 +1,34 @@
|
||||
# Changelog
|
||||
|
||||
## 1.0.22
|
||||
|
||||
Plugin API 1.13.0.
|
||||
|
||||
### Added
|
||||
|
||||
- `contributes.mobile` in the manifest says how a plugin shows in the Termix mobile app: `webview`, `native` or `none`, with an optional mobile bundle, screen sizes, views and a note
|
||||
- `termix-plugin build` bundles `src/mobile` into the `contributes.mobile.entry` file, and `validate` checks that it exists
|
||||
- `@termix-ssh/plugin-sdk/frame-host` runs one plugin view outside the shell, with core's bridge, registries and CSS, so the mobile app can show `webview` plugins
|
||||
- SSH transport providers get the host's owner, sync id, connection origin and local only flag in `claims` and `open`, and core's SSH relay takes a `syncId` instead of a host id
|
||||
- `ctx.sync.host.entities.idsOf` maps sync ids to the local ids of the user's own rows of one type
|
||||
- Rail items take `useStatus` for a small ok, warning or error dot on the icon
|
||||
- `shell.editHost(hostId)` opens the editor of a saved host
|
||||
- A sync entity can be read only with `load`, `write` and `erase`, so a plugin can sync rows a user does not own, like a shared library, down to linked desktops
|
||||
- `getFolderAuthOverride` and `setFolderAuthOverride` in `@termix-ssh/plugin-sdk/ui` read and set a user's own login for the shared hosts in a folder
|
||||
|
||||
### Fixed
|
||||
|
||||
- `@termix-ssh/plugin-sdk/ui` is built in production mode, so outside Termix it no longer sends requests to the Vite dev server path
|
||||
- `execCommand` buffers output and decodes it once as strict UTF-8 with a GBK fallback, exposed as `decodeCommandOutput`, so messages from a Windows host on a legacy codepage are readable instead of � characters
|
||||
|
||||
## 1.0.21
|
||||
|
||||
Plugin API 1.12.0.
|
||||
|
||||
### Added
|
||||
|
||||
- `@termix-ssh/plugin-sdk/host-scripts`: Docker, Linux metrics, systemd, journal and OpenRC command builders and parsers, plus `scriptShell()` and `passwordSudoScript()` to send scripts to `bash -s` on stdin. It has no Node or ssh2 imports, so the Termix mobile app runs the same code
|
||||
|
||||
## 1.0.20
|
||||
|
||||
Plugin API 1.12.0.
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Termix plugin guide
|
||||
|
||||
SDK 1.0.20 | Plugin API 1.12.0
|
||||
SDK 1.0.22 | Plugin API 1.13.0
|
||||
|
||||
This guide is for anyone, person or AI coding tool, building a Termix plugin. It ships inside
|
||||
`@termix-ssh/plugin-sdk`, so the copy in your `node_modules` always matches the SDK you have installed.
|
||||
@@ -175,7 +175,49 @@ Unknown fields are refused at every level, so a typo fails validation. The schem
|
||||
|
||||
`contributes` holds `tabs`, `panels`, `dashboardCards`, `actions`, `actionSlots`, `permissions`,
|
||||
`settings`, `protocols`, `auth`, `syncEntities`, `keybindingActions`, `http`, `guest`, `guestViews`,
|
||||
`uiPresets`, `uses`, `layouts` and `themes`. Frontend `register*` calls need their ids declared here first.
|
||||
`uiPresets`, `uses`, `layouts`, `themes` and `mobile`. Frontend `register*` calls need their ids declared here first.
|
||||
|
||||
### Mobile app
|
||||
|
||||
`contributes.mobile` says how the plugin shows in the Termix mobile app. Leave it out and the app treats the
|
||||
plugin as having nothing to show (official plugins are mapped by the app itself).
|
||||
|
||||
```json
|
||||
"mobile": { "mode": "webview", "views": ["hello"], "sizes": ["phone", "tablet"] }
|
||||
```
|
||||
|
||||
| Field | Notes |
|
||||
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `mode` | `webview` (the app shows your UI from the server), `native` (the app has its own screens) or `none`. |
|
||||
| `entry` | `webview` only. A bundle made for the app, like `dist/mobile.js`, next to `frontend.js`. Unset: your normal frontend runs in a phone sized frame. |
|
||||
| `sizes` | `webview` only. `phone`, `tablet` or both (the default). |
|
||||
| `views` | `webview` only. Ids from your `tabs`, `panels` or `dashboardCards` the app offers. Default: every tab. |
|
||||
| `feature` | `native` only. The app feature that stands in for the plugin. Default: the plugin id. |
|
||||
| `note` | A locale key or plain text the app shows next to the plugin. |
|
||||
|
||||
`build` makes `entry` from `src/mobile/index.tsx`, and it shares `frontend.css`.
|
||||
|
||||
How a `webview` plugin runs in the app:
|
||||
|
||||
- Only your plugin loads, with the same app object, SDK hooks and `/ui` kit as the web app. Each view opens
|
||||
on its own screen: a tab with `host-context-menu` in `openFrom` opens from a host, the rest from the app's
|
||||
plugin list.
|
||||
- Every request and socket goes through the app, which adds the login, proxy headers and client
|
||||
certificate. The app only lets through your own `/plugin-api`, `/plugin-ws` and `/plugin-assets`, your
|
||||
settings and a short list of core reads (hosts, folders, permissions, current user, version, health,
|
||||
activity). Other core routes answer 403, so call your own backend instead.
|
||||
- Images load straight from the server, without proxy headers or a client certificate.
|
||||
- Nothing in `localStorage` survives closing the view. Keep preferences in settings.
|
||||
- Other plugins' views, extensions and components are not there, and neither is the shell (`useShell()`
|
||||
is null). `/ui` names newer than the app's copy of the SDK make the view say it needs a newer app.
|
||||
- The app checks your `engine.api` against the plugin API of its own copy of the SDK. When the app's API
|
||||
is too old for the range, it asks the user to update the app instead of opening the view. When the range
|
||||
is for an older API major, it asks to update the plugin. Ask only for the API you use.
|
||||
- Turning a plugin off on the server hides it in the app the next time the app checks: when it comes back
|
||||
to the front, when the list is pulled down, or when any request answers 503 with your `pluginId`.
|
||||
|
||||
Termix 26.10.5 and older refuse any manifest with `mobile`, so a plugin that declares it needs
|
||||
`"engine": { "termix": ">=26.10.6", "api": "^1.13" }`.
|
||||
|
||||
Capabilities and permissions are different things. A capability (`hosts:read`, with a colon) is what your
|
||||
code may reach. A permission (`hello.use`, with a dot) is what a user may do.
|
||||
@@ -304,7 +346,7 @@ router.post("/notes", async (req, res) => {
|
||||
- `ctx.rbac.require("manage")` on a single route, `await ctx.rbac.has("manage")` in code. A full id like
|
||||
`hosts.edit` checks a core permission.
|
||||
- Host access: `ctx.hosts.checkAccess(hostId, "connect" | "view" | "edit" | "manage")`.
|
||||
- Transports: with `ssh:transport`, `ctx.ssh.transports.provide({ claims(hostId), open({ id, ip, port }) })`
|
||||
- Transports: with `ssh:transport`, `ctx.ssh.transports.provide({ claims(hostId, host), open(host) })`, where `host` has `id`, `ip`, `port` and on Termix 26.10.6+ also `userId`, `syncId`, `connectionOrigin` and `localOnly`
|
||||
returns a stream the SSH client uses instead of a direct, proxy or jump host connection. Core also serves
|
||||
`/plugin-ws/core/ssh-relay?hostId=` for callers with connect access, so one Termix can relay to another.
|
||||
- Managed hosts: with `hosts:lock`, `ctx.hosts.locks.provide({ isLocked, note, allowManualCreate })` makes
|
||||
@@ -335,7 +377,9 @@ try {
|
||||
|
||||
`ctx.ssh.withConnection(hostId, { pool, purpose }, fn)` borrows a pooled connection for frequent short
|
||||
commands. `@termix-ssh/plugin-sdk/host-commands` has helpers to detect the OS and run package manager and
|
||||
sudo commands. Hosts from `ctx.hosts` never carry secrets. Pass the host or its id to `ctx.ssh`.
|
||||
sudo commands. `@termix-ssh/plugin-sdk/host-scripts` builds Docker, metrics, systemd and journal
|
||||
commands and parses their output; send a script on stdin to the command `scriptShell()` returns. Hosts from
|
||||
`ctx.hosts` never carry secrets. Pass the host or its id to `ctx.ssh`.
|
||||
|
||||
### The desktop app
|
||||
|
||||
@@ -451,6 +495,23 @@ Other storage: `ctx.kv` for a few values, `ctx.settings` for settings, `ctx.secr
|
||||
`ctx.files.dataDir()` for files. To sync a table to a linked desktop, use `ctx.sync.registerEntity` and
|
||||
`contributes.syncEntities`. The entity name is part of the protocol and never changes.
|
||||
|
||||
A registered table syncs the rows each user owns, both ways. For data you keep for the whole server (a shared
|
||||
library, rows other users share), register a read only entity with `table: null`, `readOnly: true` and `load`,
|
||||
`write` and `erase` (Termix 26.10.6+). `load(userId)` returns the rows that user should get, each with a
|
||||
`syncId`. The desktop keeps them with `write` and drops them with `erase`, and never pushes them back:
|
||||
|
||||
```ts
|
||||
ctx.sync.registerEntity({
|
||||
type: "sharedIcons",
|
||||
table: null,
|
||||
readOnly: true,
|
||||
order: 70,
|
||||
load: (userId) => iconsVisibleTo(userId),
|
||||
write: (userId, row) => storeCopy(userId, row),
|
||||
erase: (userId, syncId) => dropCopy(userId, syncId),
|
||||
});
|
||||
```
|
||||
|
||||
## Frontend
|
||||
|
||||
```tsx
|
||||
@@ -905,6 +966,7 @@ To run your own registry instead, see https://docs.termix.site/develop/registrie
|
||||
| `@termix-ssh/plugin-sdk/testing` | `createMockCtx`, `createTestDb`, `renderWithApp`, `createFakeContext` |
|
||||
| `@termix-ssh/plugin-sdk/vitest-preset` | `pluginVitestConfig` |
|
||||
| `@termix-ssh/plugin-sdk/host-commands` | OS detection, package manager and sudo helpers over ssh2 |
|
||||
| `@termix-ssh/plugin-sdk/host-scripts` | Docker, metrics, systemd and journal command builders and parsers, scripts sent to `bash -s` |
|
||||
| `@termix-ssh/plugin-sdk/ssh-certs` | `applyCertificateAuth()` for certificate based SSH auth |
|
||||
| `@termix-ssh/plugin-sdk/ssh-keys` | `generateSshKeyPair()`, `detectSshKeyType()`, `publicKeyFromPrivate()`, `validateSshKeyPair()` |
|
||||
| `@termix-ssh/plugin-sdk/desktop` | The desktop app bridge, typed. Check it exists before use |
|
||||
|
||||
@@ -25,6 +25,43 @@ const FRONTEND_ENTRIES = [
|
||||
"src/frontend/index.mjs",
|
||||
"src/frontend/index.js",
|
||||
];
|
||||
const MOBILE_ENTRIES = [
|
||||
"src/mobile/index.tsx",
|
||||
"src/mobile/index.ts",
|
||||
"src/mobile/index.mjs",
|
||||
"src/mobile/index.js",
|
||||
];
|
||||
|
||||
/** Builds a bundle that runs in a browser against core's shared modules. */
|
||||
async function buildBrowserBundle(entry, outfile, outDir) {
|
||||
await esbuild.build({
|
||||
entryPoints: [entry],
|
||||
outfile,
|
||||
bundle: true,
|
||||
format: "esm",
|
||||
platform: "browser",
|
||||
target: "es2022",
|
||||
jsx: "automatic",
|
||||
sourcemap: true,
|
||||
logLevel: "warning",
|
||||
external: FRONTEND_EXTERNALS,
|
||||
// Vite replaces these in the dev server; a plugin bundle has to have
|
||||
// them too, or code that reads them throws when the plugin loads.
|
||||
define: {
|
||||
"process.env.NODE_ENV": '"production"',
|
||||
"import.meta.env.DEV": "false",
|
||||
"import.meta.env.PROD": "true",
|
||||
"import.meta.env.MODE": '"production"',
|
||||
"import.meta.env.SSR": "false",
|
||||
"import.meta.env":
|
||||
'{"DEV":false,"PROD":true,"MODE":"production","SSR":false,"BASE_URL":"/"}',
|
||||
},
|
||||
plugins: [
|
||||
externalRequireInterop(FRONTEND_EXTERNALS),
|
||||
staticUrlImports({ outDir }),
|
||||
],
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* A bundled CommonJS package that calls require("react/jsx-runtime") (or any
|
||||
@@ -192,15 +229,12 @@ export async function buildTailwind(cwd, outDir) {
|
||||
// build() adds to what a compiler already emitted, so each half gets its own.
|
||||
const compiler = () =>
|
||||
compile(input, { base: path.dirname(THEME_CSS), onDependency: () => {} });
|
||||
const scanner = new Scanner({
|
||||
sources: [
|
||||
{
|
||||
base: path.join(cwd, "src", "frontend"),
|
||||
pattern: "**/*",
|
||||
negated: false,
|
||||
},
|
||||
],
|
||||
});
|
||||
// The mobile bundle uses the same stylesheet.
|
||||
const sources = ["frontend", "mobile"]
|
||||
.map((dir) => path.join(cwd, "src", dir))
|
||||
.filter((dir, index) => index === 0 || fs.existsSync(dir))
|
||||
.map((base) => ({ base, pattern: "**/*", negated: false }));
|
||||
const scanner = new Scanner({ sources });
|
||||
// Flattened and minified the way core's own CSS is, so it does not rely
|
||||
// on native CSS nesting.
|
||||
const emit = async (candidates, options) =>
|
||||
@@ -297,33 +331,18 @@ export async function build({ cwd }) {
|
||||
|
||||
const frontendEntry = resolveEntry(cwd, FRONTEND_ENTRIES);
|
||||
if (frontendEntry) {
|
||||
await esbuild.build({
|
||||
entryPoints: [frontendEntry],
|
||||
outfile: path.join(outDir, "frontend.js"),
|
||||
bundle: true,
|
||||
format: "esm",
|
||||
platform: "browser",
|
||||
target: "es2022",
|
||||
jsx: "automatic",
|
||||
sourcemap: true,
|
||||
logLevel: "warning",
|
||||
external: FRONTEND_EXTERNALS,
|
||||
// Vite replaces these in the dev server; a plugin bundle has to have
|
||||
// them too, or code that reads them throws when the plugin loads.
|
||||
define: {
|
||||
"process.env.NODE_ENV": '"production"',
|
||||
"import.meta.env.DEV": "false",
|
||||
"import.meta.env.PROD": "true",
|
||||
"import.meta.env.MODE": '"production"',
|
||||
"import.meta.env.SSR": "false",
|
||||
"import.meta.env":
|
||||
'{"DEV":false,"PROD":true,"MODE":"production","SSR":false,"BASE_URL":"/"}',
|
||||
},
|
||||
plugins: [
|
||||
externalRequireInterop(FRONTEND_EXTERNALS),
|
||||
staticUrlImports({ outDir }),
|
||||
],
|
||||
});
|
||||
await buildBrowserBundle(
|
||||
frontendEntry,
|
||||
path.join(outDir, "frontend.js"),
|
||||
outDir,
|
||||
);
|
||||
}
|
||||
|
||||
// A bundle the mobile app loads in its WebView, next to the frontend one.
|
||||
const mobileEntry = resolveEntry(cwd, MOBILE_ENTRIES);
|
||||
const mobileOut = manifest.contributes?.mobile?.entry;
|
||||
if (mobileEntry && typeof mobileOut === "string") {
|
||||
await buildBrowserBundle(mobileEntry, path.join(cwd, mobileOut), outDir);
|
||||
}
|
||||
|
||||
if (frontendEntry) await buildTailwind(cwd, outDir);
|
||||
|
||||
@@ -28,6 +28,10 @@ export async function validate({ cwd }) {
|
||||
// A theme only plugin has no frontend code.
|
||||
...(isThemeOnly(raw) ? [] : [raw.frontend ?? "dist/frontend.js"]),
|
||||
raw.locales ?? "locales",
|
||||
// Built from src/mobile by termix-plugin build.
|
||||
...(typeof raw.contributes?.mobile?.entry === "string"
|
||||
? [raw.contributes.mobile.entry]
|
||||
: []),
|
||||
];
|
||||
for (const rel of referenced) {
|
||||
if (!fs.existsSync(path.join(cwd, rel))) {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@termix-ssh/plugin-sdk",
|
||||
"version": "1.0.20",
|
||||
"version": "1.0.22",
|
||||
"description": "The contract between Termix core and a plugin: types, the capability catalog and the manifest schema.",
|
||||
"license": "Apache-2.0",
|
||||
"repository": {
|
||||
@@ -81,6 +81,10 @@
|
||||
"types": "./dist/host-commands.d.ts",
|
||||
"default": "./dist/host-commands.js"
|
||||
},
|
||||
"./host-scripts": {
|
||||
"types": "./dist/host-scripts/index.d.ts",
|
||||
"default": "./dist/host-scripts/index.js"
|
||||
},
|
||||
"./ssh-certs": {
|
||||
"types": "./dist/ssh-certs.d.ts",
|
||||
"default": "./dist/ssh-certs.js"
|
||||
@@ -98,6 +102,10 @@
|
||||
"./testing-host": {
|
||||
"default": "./dist/host/testing-host.js"
|
||||
},
|
||||
"./frame-host": {
|
||||
"default": "./dist/host/frame-host.js"
|
||||
},
|
||||
"./frame-host.css": "./dist/host/frame-host.css",
|
||||
"./theme.css": "./dist/host/theme.css"
|
||||
},
|
||||
"files": [
|
||||
|
||||
@@ -1239,6 +1239,48 @@
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"mobile": {
|
||||
"type": "object",
|
||||
"description": "How the plugin shows in the Termix mobile app. Needs plugin API 1.13 (Termix 26.10.6).",
|
||||
"additionalProperties": false,
|
||||
"required": ["mode"],
|
||||
"properties": {
|
||||
"mode": {
|
||||
"type": "string",
|
||||
"enum": ["webview", "native", "none"],
|
||||
"description": "webview: the app shows the plugin's UI from the server. native: the app has its own screens. none: nothing to show in the app."
|
||||
},
|
||||
"entry": {
|
||||
"type": "string",
|
||||
"pattern": "\\.js$",
|
||||
"description": "webview only. A bundle built for the app, in the same folder as the frontend bundle. Unset means the normal frontend runs in a phone sized frame."
|
||||
},
|
||||
"sizes": {
|
||||
"type": "array",
|
||||
"minItems": 1,
|
||||
"uniqueItems": true,
|
||||
"items": { "type": "string", "enum": ["phone", "tablet"] },
|
||||
"description": "webview only. Screen sizes the UI works at. Defaults to both."
|
||||
},
|
||||
"views": {
|
||||
"type": "array",
|
||||
"minItems": 1,
|
||||
"uniqueItems": true,
|
||||
"items": { "type": "string", "minLength": 1 },
|
||||
"description": "webview only. Tab, panel or card ids the app offers. Defaults to every tab."
|
||||
},
|
||||
"feature": {
|
||||
"type": "string",
|
||||
"pattern": "^[a-z][a-z0-9-]{1,39}$",
|
||||
"description": "native only. The app feature that stands in for this plugin. Defaults to the plugin id."
|
||||
},
|
||||
"note": {
|
||||
"type": "string",
|
||||
"minLength": 1,
|
||||
"description": "i18n key in the plugin's namespace, or plain text, shown in the app."
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
@@ -177,8 +177,24 @@ export interface SyncWriteEvent {
|
||||
export interface SyncEntityRegistration {
|
||||
/** Stable wire name. Never change it: records on both sides match on it. */
|
||||
type: string;
|
||||
/** The table, as returned by ctx.db.define. */
|
||||
/** The table, as returned by ctx.db.define. Null for an entity with `load`. */
|
||||
table: unknown;
|
||||
/**
|
||||
* Server to desktop only: a desktop never pushes these rows. Required with
|
||||
* `load`.
|
||||
*/
|
||||
readOnly?: boolean;
|
||||
/**
|
||||
* Builds the rows the user gets instead of reading the rows they own in
|
||||
* `table`, for data kept for the whole server (a shared library, rows other
|
||||
* users share with them). Rows are on the wire: plaintext, each with a
|
||||
* syncId. Needs `readOnly: true`, `write` and `erase`.
|
||||
*/
|
||||
load?: (userId: string) => Promise<SyncRow[]>;
|
||||
/** Keeps a copy of an inbound row on the desktop, for an entity with `load`. */
|
||||
write?: (userId: string, wire: SyncRow) => Promise<void>;
|
||||
/** Drops the desktop copy with this syncId, for an entity with `load`. */
|
||||
erase?: (userId: string, syncId: string) => Promise<void>;
|
||||
/** Column holding the owning user id. Defaults to "userId". */
|
||||
userColumn?: string;
|
||||
/** Fields stored encrypted with the owner's data key. Plaintext on the wire. */
|
||||
@@ -470,6 +486,12 @@ export interface PluginSyncHost {
|
||||
ensureCore: () => Promise<void>;
|
||||
onChanged: (listener: () => void) => () => void;
|
||||
onLocalWrite: (listener: () => void) => () => void;
|
||||
/** Local ids of the user's own rows of a type, by sync id. Termix 26.10.6+. */
|
||||
idsOf?: (
|
||||
type: string,
|
||||
userId: string,
|
||||
syncIds: string[],
|
||||
) => Promise<Record<string, number>>;
|
||||
};
|
||||
|
||||
/** Rows and bookkeeping of one local user's replica. */
|
||||
@@ -1813,13 +1835,21 @@ export interface PluginNetwork {
|
||||
* asked for every connection, so it must be quick. `open` returns a stream
|
||||
* the SSH client runs over, like a relayed socket.
|
||||
*/
|
||||
/** The host a transport is asked about. Fields past port come from Termix 26.10.6. */
|
||||
export interface PluginSshTransportHost {
|
||||
id: number;
|
||||
ip: string;
|
||||
port: number;
|
||||
/** Owner of the host row. */
|
||||
userId?: string | null;
|
||||
syncId?: string | null;
|
||||
connectionOrigin?: "local" | "remote" | null;
|
||||
localOnly?: boolean;
|
||||
}
|
||||
|
||||
export interface PluginSshTransportProvider {
|
||||
claims: (hostId: number) => boolean;
|
||||
open: (host: {
|
||||
id: number;
|
||||
ip: string;
|
||||
port: number;
|
||||
}) => Promise<import("node:stream").Duplex>;
|
||||
claims: (hostId: number, host?: PluginSshTransportHost) => boolean;
|
||||
open: (host: PluginSshTransportHost) => Promise<import("node:stream").Duplex>;
|
||||
}
|
||||
|
||||
export interface PluginSshTransports {
|
||||
|
||||
@@ -206,6 +206,8 @@ export interface ShellApi {
|
||||
* user reviews and saves it. Absent in some shells.
|
||||
*/
|
||||
openHostEditor?: (draft?: HostDraft) => void;
|
||||
/** Opens the editor of a saved host. Termix 26.10.6+, absent in some shells. */
|
||||
editHost?: (hostId: number) => void;
|
||||
/** Opens a rail view in the left sidebar. */
|
||||
openRailView: (id: string) => void;
|
||||
/** Closes a rail view wherever it is shown. */
|
||||
@@ -425,6 +427,11 @@ export interface RailItemContribution {
|
||||
* Zero or nothing shows no badge.
|
||||
*/
|
||||
useBadge?: () => number | null | undefined;
|
||||
/**
|
||||
* A hook for a small status dot on the icon: "ok" (green), "warning" or
|
||||
* "error". Nothing shows no dot. Layouts from Termix 26.10.6 draw it.
|
||||
*/
|
||||
useStatus?: () => "ok" | "warning" | "error" | null | undefined;
|
||||
}
|
||||
|
||||
export interface PanelProps {
|
||||
|
||||
@@ -11,6 +11,9 @@
|
||||
|
||||
export type { Client, ClientChannel } from "ssh2";
|
||||
import type { Client, ClientChannel } from "ssh2";
|
||||
// Homebrew and OrbStack paths a non-interactive shell misses.
|
||||
import { EXTRA_PATH_DIRS } from "./host-scripts/docker.js";
|
||||
export { EXTRA_PATH_DIRS };
|
||||
|
||||
export interface ExecResult {
|
||||
stdout: string;
|
||||
@@ -18,6 +21,30 @@ export interface ExecResult {
|
||||
code: number | null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Decodes raw command output. Strict UTF-8 first; when that fails, tries GBK,
|
||||
* which is what a Chinese-locale Windows console sends (its bytes are almost
|
||||
* never valid UTF-8) and keeps it only when it decodes without replacement
|
||||
* characters. Anything else falls back to lossy UTF-8, the old behavior.
|
||||
*/
|
||||
export function decodeCommandOutput(buf: Buffer): string {
|
||||
try {
|
||||
return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(
|
||||
buf,
|
||||
);
|
||||
} catch {
|
||||
// not valid UTF-8, try the legacy codepage
|
||||
}
|
||||
try {
|
||||
// A Node built with small-ICU has no GBK decoder and throws here.
|
||||
const gbk = new TextDecoder("gbk").decode(buf);
|
||||
if (!gbk.includes("�")) return gbk;
|
||||
} catch {
|
||||
// expected - fall through to lossy UTF-8
|
||||
}
|
||||
return buf.toString("utf8");
|
||||
}
|
||||
|
||||
/** Runs one non-interactive command over an existing ssh2 client. */
|
||||
export function execCommand(
|
||||
client: Client,
|
||||
@@ -62,8 +89,10 @@ export function execCommand(
|
||||
}
|
||||
|
||||
stream = _stream;
|
||||
let stdout = "";
|
||||
let stderr = "";
|
||||
// Chunks are buffered and decoded once on close: a multi-byte character
|
||||
// can be split across chunks, and charset detection needs it whole.
|
||||
const stdout: Buffer[] = [];
|
||||
const stderr: Buffer[] = [];
|
||||
let exitCode: number | null = null;
|
||||
|
||||
stream
|
||||
@@ -72,11 +101,15 @@ export function execCommand(
|
||||
settled = true;
|
||||
exitCode = typeof code === "number" ? code : null;
|
||||
cleanup();
|
||||
resolve({ stdout, stderr, code: exitCode });
|
||||
resolve({
|
||||
stdout: decodeCommandOutput(Buffer.concat(stdout)),
|
||||
stderr: decodeCommandOutput(Buffer.concat(stderr)),
|
||||
code: exitCode,
|
||||
});
|
||||
}
|
||||
})
|
||||
.on("data", (data: Buffer) => {
|
||||
stdout += data.toString("utf8");
|
||||
stdout.push(data);
|
||||
})
|
||||
.on("error", (streamErr: Error) => {
|
||||
if (!settled) {
|
||||
@@ -89,7 +122,7 @@ export function execCommand(
|
||||
if (stream.stderr) {
|
||||
stream.stderr
|
||||
.on("data", (data: Buffer) => {
|
||||
stderr += data.toString("utf8");
|
||||
stderr.push(data);
|
||||
})
|
||||
.on("error", (stderrErr: Error) => {
|
||||
if (!settled) {
|
||||
@@ -114,14 +147,6 @@ export interface PlatformInfo {
|
||||
osPrettyName: string | null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Non-interactive SSH shells don't source ~/.zprofile or ~/.bash_profile,
|
||||
* so PATH additions from installers like Homebrew or OrbStack are missing.
|
||||
* Extend PATH with their common install locations before probing.
|
||||
*/
|
||||
export const EXTRA_PATH_DIRS =
|
||||
'/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:"$HOME/.orbstack/bin"';
|
||||
|
||||
const DOCKER_PROBE =
|
||||
`command -v docker >/dev/null 2>&1` +
|
||||
` || [ -S /var/run/docker.sock ]` +
|
||||
|
||||
@@ -0,0 +1,468 @@
|
||||
/**
|
||||
* Docker and Podman command builders and output parsers.
|
||||
*
|
||||
* Container ids and names are checked with CONTAINER_ID_RE before they go on
|
||||
* a command line, so they need no quoting. Anything free form is quoted.
|
||||
*/
|
||||
import { HostScriptError } from "./text.js";
|
||||
|
||||
export type ContainerRuntime = "docker" | "podman";
|
||||
|
||||
export function normalizeContainerRuntime(value: unknown): ContainerRuntime {
|
||||
return value === "podman" ? "podman" : "docker";
|
||||
}
|
||||
|
||||
export function getRuntimeLabel(runtime: ContainerRuntime): string {
|
||||
return runtime === "podman" ? "Podman" : "Docker";
|
||||
}
|
||||
|
||||
/**
|
||||
* Non-interactive SSH shells don't source ~/.zprofile or ~/.bash_profile,
|
||||
* so PATH additions from installers like Homebrew or OrbStack are missing.
|
||||
*/
|
||||
export const EXTRA_PATH_DIRS =
|
||||
'/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:"$HOME/.orbstack/bin"';
|
||||
|
||||
export function containerCommand(
|
||||
runtime: ContainerRuntime | undefined,
|
||||
args: string,
|
||||
isWindows = false,
|
||||
): string {
|
||||
const cli = `${normalizeContainerRuntime(runtime)} ${args}`;
|
||||
// cmd and PowerShell don't understand the POSIX env prefix.
|
||||
return isWindows ? cli : `PATH="${EXTRA_PATH_DIRS}:$PATH" ${cli}`;
|
||||
}
|
||||
|
||||
export const CONTAINER_ID_RE = /^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/;
|
||||
export const DOCKER_TIMESTAMP_RE = /^[0-9T:.Z+-]+$/;
|
||||
|
||||
export function isContainerId(value: unknown): value is string {
|
||||
return (
|
||||
typeof value === "string" &&
|
||||
value.length <= 256 &&
|
||||
CONTAINER_ID_RE.test(value)
|
||||
);
|
||||
}
|
||||
|
||||
function requireContainer(id: string): string {
|
||||
if (!isContainerId(id))
|
||||
throw new HostScriptError("That is not a valid container id");
|
||||
return id;
|
||||
}
|
||||
|
||||
export const CONTAINER_ACTIONS = [
|
||||
"start",
|
||||
"stop",
|
||||
"restart",
|
||||
"pause",
|
||||
"unpause",
|
||||
] as const;
|
||||
export type ContainerAction = (typeof CONTAINER_ACTIONS)[number];
|
||||
|
||||
const LIST_FORMAT_UNIX = `'{"id":"{{.ID}}","name":"{{.Names}}","image":"{{.Image}}","status":"{{.Status}}","state":"{{.State}}","ports":"{{.Ports}}","created":"{{.CreatedAt}}"}' `;
|
||||
const LIST_FORMAT_WINDOWS = `"{\\"id\\":\\"{{.ID}}\\",\\"name\\":\\"{{.Names}}\\",\\"image\\":\\"{{.Image}}\\",\\"status\\":\\"{{.Status}}\\",\\"state\\":\\"{{.State}}\\",\\"ports\\":\\"{{.Ports}}\\",\\"created\\":\\"{{.CreatedAt}}\\"}"`;
|
||||
const STATS_FORMAT_UNIX = `'{"cpu":"{{.CPUPerc}}","memory":"{{.MemUsage}}","memoryPercent":"{{.MemPerc}}","netIO":"{{.NetIO}}","blockIO":"{{.BlockIO}}","pids":"{{.PIDs}}"}' `;
|
||||
const STATS_FORMAT_WINDOWS = `"{\\"cpu\\":\\"{{.CPUPerc}}\\",\\"memory\\":\\"{{.MemUsage}}\\",\\"memoryPercent\\":\\"{{.MemPerc}}\\",\\"netIO\\":\\"{{.NetIO}}\\",\\"blockIO\\":\\"{{.BlockIO}}\\",\\"pids\\":\\"{{.PIDs}}\\"}"`;
|
||||
|
||||
export function listFormat(isWindows: boolean): string {
|
||||
return isWindows ? LIST_FORMAT_WINDOWS : LIST_FORMAT_UNIX;
|
||||
}
|
||||
|
||||
export function statsFormat(isWindows: boolean): string {
|
||||
return isWindows ? STATS_FORMAT_WINDOWS : STATS_FORMAT_UNIX;
|
||||
}
|
||||
|
||||
/** One row of `ps --format listFormat()`. */
|
||||
export interface ContainerRow {
|
||||
id: string;
|
||||
name: string;
|
||||
image: string;
|
||||
status: string;
|
||||
state: string;
|
||||
ports: string;
|
||||
created: string;
|
||||
}
|
||||
|
||||
/** CLI arguments, without the runtime, for each container command. */
|
||||
export const dockerArgs = {
|
||||
version: () => "--version",
|
||||
ping: () => "ps",
|
||||
list: (all: boolean, isWindows = false) =>
|
||||
`ps ${all ? "-a " : ""}--format ${listFormat(isWindows)}`,
|
||||
inspect: (id: string) => `inspect ${requireContainer(id)}`,
|
||||
stats: (id: string, isWindows = false) =>
|
||||
`stats ${requireContainer(id)} --no-stream --format ${statsFormat(isWindows)}`,
|
||||
action: (action: ContainerAction, id: string) => {
|
||||
if (!CONTAINER_ACTIONS.includes(action))
|
||||
throw new HostScriptError("Unknown action");
|
||||
return `${action} ${requireContainer(id)}`;
|
||||
},
|
||||
remove: (id: string, force: boolean) =>
|
||||
`rm ${force ? "-f " : ""}${requireContainer(id)}`,
|
||||
logs: (
|
||||
id: string,
|
||||
options: {
|
||||
tail?: number;
|
||||
timestamps?: boolean;
|
||||
since?: string;
|
||||
until?: string;
|
||||
} = {},
|
||||
) => {
|
||||
let args = `logs ${requireContainer(id)}`;
|
||||
if (options.tail && options.tail > 0)
|
||||
args += ` --tail ${Math.floor(options.tail)}`;
|
||||
if (options.timestamps) args += " --timestamps";
|
||||
if (options.since && DOCKER_TIMESTAMP_RE.test(options.since)) {
|
||||
args += ` --since ${options.since}`;
|
||||
}
|
||||
if (options.until && DOCKER_TIMESTAMP_RE.test(options.until)) {
|
||||
args += ` --until ${options.until}`;
|
||||
}
|
||||
return `${args} 2>&1`;
|
||||
},
|
||||
states: () => `ps -a --format ${PS_STATE_FORMAT}`,
|
||||
composeProjects: () => "compose ls -a --format json",
|
||||
};
|
||||
|
||||
/** The version from `docker --version` or `podman --version`. */
|
||||
export function parseRuntimeVersion(output: string): string {
|
||||
return output.match(/(?:Docker|podman) version ([^\s,]+)/i)?.[1] ?? "unknown";
|
||||
}
|
||||
|
||||
export type RuntimeProblem =
|
||||
"NOT_INSTALLED" | "DAEMON_NOT_RUNNING" | "PERMISSION_DENIED" | "DOCKER_ERROR";
|
||||
|
||||
/** Sorts a failed `docker ps` into a reason the UI can explain. */
|
||||
export function classifyRuntimeError(message: string): RuntimeProblem {
|
||||
if (
|
||||
/command not found|not found: (docker|podman)|No such file or directory/i.test(
|
||||
message,
|
||||
)
|
||||
) {
|
||||
return "NOT_INSTALLED";
|
||||
}
|
||||
if (message.includes("Cannot connect to the Docker daemon"))
|
||||
return "DAEMON_NOT_RUNNING";
|
||||
if (/permission denied/i.test(message)) return "PERMISSION_DENIED";
|
||||
return "DOCKER_ERROR";
|
||||
}
|
||||
|
||||
/** Parses `ps --format listFormat()` output, skipping lines that are not JSON. */
|
||||
export function parseContainerList(output: string): Record<string, unknown>[] {
|
||||
return output
|
||||
.split("\n")
|
||||
.filter((line) => line.trim())
|
||||
.flatMap((line) => {
|
||||
try {
|
||||
return [JSON.parse(line) as Record<string, unknown>];
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
export interface ContainerStats {
|
||||
cpu: string;
|
||||
memoryUsed: string;
|
||||
memoryLimit: string;
|
||||
memoryPercent: string;
|
||||
netInput: string;
|
||||
netOutput: string;
|
||||
blockRead: string;
|
||||
blockWrite: string;
|
||||
pids: string;
|
||||
}
|
||||
|
||||
/** Parses one `stats --no-stream --format statsFormat()` line. Throws on bad JSON. */
|
||||
export function parseContainerStats(output: string): ContainerStats {
|
||||
const raw = JSON.parse(output.trim()) as Record<string, string>;
|
||||
const split = (value: string | undefined) => {
|
||||
const [first, second] = (value ?? "").split(" / ");
|
||||
return [first?.trim() || "0B", second?.trim() || "0B"];
|
||||
};
|
||||
const [memoryUsed, memoryLimit] = split(raw.memory);
|
||||
const [netInput, netOutput] = split(raw.netIO);
|
||||
const [blockRead, blockWrite] = split(raw.blockIO);
|
||||
return {
|
||||
cpu: raw.cpu,
|
||||
memoryUsed,
|
||||
memoryLimit,
|
||||
memoryPercent: raw.memoryPercent,
|
||||
netInput,
|
||||
netOutput,
|
||||
blockRead,
|
||||
blockWrite,
|
||||
pids: raw.pids,
|
||||
};
|
||||
}
|
||||
|
||||
export interface ContainerState {
|
||||
/** Docker's own state word: running, exited, restarting, ... */
|
||||
state: string;
|
||||
/** Health from the status text, when the image declares a healthcheck. */
|
||||
unhealthy: boolean;
|
||||
}
|
||||
|
||||
export type DockerEventName = "exited" | "started" | "unhealthy" | "restarting";
|
||||
|
||||
export const PS_STATE_FORMAT = `'{"name":"{{.Names}}","state":"{{.State}}","status":"{{.Status}}"}'`;
|
||||
|
||||
/** Parses `ps -a --format PS_STATE_FORMAT` output, one JSON object per line. */
|
||||
export function parseContainerStates(
|
||||
output: string,
|
||||
): Map<string, ContainerState> {
|
||||
const states = new Map<string, ContainerState>();
|
||||
for (const line of output.split("\n")) {
|
||||
const trimmed = line.trim();
|
||||
if (!trimmed) continue;
|
||||
try {
|
||||
const parsed = JSON.parse(trimmed) as {
|
||||
name?: string;
|
||||
state?: string;
|
||||
status?: string;
|
||||
};
|
||||
if (!parsed.name) continue;
|
||||
states.set(parsed.name, {
|
||||
state: (parsed.state ?? "").toLowerCase(),
|
||||
unhealthy: /\(unhealthy\)/i.test(parsed.status ?? ""),
|
||||
});
|
||||
} catch {
|
||||
// A partial line is not worth failing the whole poll over.
|
||||
}
|
||||
}
|
||||
return states;
|
||||
}
|
||||
|
||||
/**
|
||||
* The events a pair of snapshots implies. A container missing from the
|
||||
* previous snapshot counts as newly seen rather than started, so the first
|
||||
* poll after a restart does not replay every running container.
|
||||
*/
|
||||
export function diffContainerStates(
|
||||
previous: Map<string, ContainerState>,
|
||||
current: Map<string, ContainerState>,
|
||||
): Array<{ container: string; event: DockerEventName }> {
|
||||
const events: Array<{ container: string; event: DockerEventName }> = [];
|
||||
for (const [name, now] of current) {
|
||||
const before = previous.get(name);
|
||||
if (!before) continue;
|
||||
if (before.state !== now.state) {
|
||||
if (now.state === "exited")
|
||||
events.push({ container: name, event: "exited" });
|
||||
else if (now.state === "running")
|
||||
events.push({ container: name, event: "started" });
|
||||
else if (now.state === "restarting") {
|
||||
events.push({ container: name, event: "restarting" });
|
||||
}
|
||||
}
|
||||
// A container can go unhealthy while it stays up.
|
||||
if (!before.unhealthy && now.unhealthy) {
|
||||
events.push({ container: name, event: "unhealthy" });
|
||||
}
|
||||
}
|
||||
return events;
|
||||
}
|
||||
|
||||
export interface ContainerCounts {
|
||||
running: number;
|
||||
stopped: number;
|
||||
unhealthy: number;
|
||||
total: number;
|
||||
}
|
||||
|
||||
/** Counts from `ps -a --format PS_STATE_FORMAT` output. */
|
||||
export function countContainers(output: string): ContainerCounts {
|
||||
const states = [...parseContainerStates(output).values()];
|
||||
const running = states.filter((s) => s.state === "running").length;
|
||||
return {
|
||||
running,
|
||||
stopped: states.length - running,
|
||||
unhealthy: states.filter((s) => s.unhealthy).length,
|
||||
total: states.length,
|
||||
};
|
||||
}
|
||||
|
||||
// Compose stacks
|
||||
|
||||
export const STACK_NAME_RE = /^[a-z0-9][a-z0-9_-]{0,62}$/;
|
||||
export const STACK_SERVICE_RE = /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,126}$/;
|
||||
export const COMPOSE_FILES = [
|
||||
"compose.yaml",
|
||||
"compose.yml",
|
||||
"docker-compose.yaml",
|
||||
"docker-compose.yml",
|
||||
];
|
||||
|
||||
export const STACK_ACTIONS = [
|
||||
"deploy",
|
||||
"redeploy",
|
||||
"pull",
|
||||
"start",
|
||||
"stop",
|
||||
"restart",
|
||||
"pause",
|
||||
"unpause",
|
||||
"down",
|
||||
"destroy",
|
||||
] as const;
|
||||
export type StackAction = (typeof STACK_ACTIONS)[number];
|
||||
|
||||
/** Actions that can target one service of a stack. */
|
||||
export const STACK_SERVICE_ACTIONS: StackAction[] = [
|
||||
"deploy",
|
||||
"pull",
|
||||
"start",
|
||||
"stop",
|
||||
"restart",
|
||||
"pause",
|
||||
"unpause",
|
||||
];
|
||||
|
||||
export type StackState =
|
||||
"running" | "partial" | "stopped" | "paused" | "not-deployed";
|
||||
|
||||
export interface StackSummary {
|
||||
name: string;
|
||||
managed: boolean;
|
||||
state: StackState;
|
||||
running: number;
|
||||
total: number;
|
||||
composeFile: string | null;
|
||||
}
|
||||
|
||||
export interface StackService {
|
||||
service: string;
|
||||
name: string;
|
||||
id: string;
|
||||
image: string;
|
||||
state: string;
|
||||
status: string;
|
||||
health: string;
|
||||
ports: string;
|
||||
}
|
||||
|
||||
/** `compose ls` and `compose ps --format json` print one object per line or one array. */
|
||||
export function parseJsonLines(output: string): Record<string, unknown>[] {
|
||||
const text = output.trim();
|
||||
if (!text) return [];
|
||||
if (text.startsWith("[")) {
|
||||
try {
|
||||
return JSON.parse(text) as Record<string, unknown>[];
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
return text.split("\n").flatMap((line) => {
|
||||
try {
|
||||
return [JSON.parse(line) as Record<string, unknown>];
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
const str = (value: unknown): string =>
|
||||
typeof value === "string" ? value : "";
|
||||
|
||||
export function parseServices(output: string): StackService[] {
|
||||
return parseJsonLines(output).map((row) => {
|
||||
const publishers = Array.isArray(row.Publishers)
|
||||
? (row.Publishers as Record<string, unknown>[])
|
||||
: [];
|
||||
const ports = publishers
|
||||
.filter((p) => Number(p.PublishedPort) > 0)
|
||||
.map((p) => `${p.PublishedPort}:${p.TargetPort}`)
|
||||
.filter((value, index, all) => all.indexOf(value) === index)
|
||||
.join(", ");
|
||||
return {
|
||||
service: str(row.Service),
|
||||
name: str(row.Name),
|
||||
id: str(row.ID),
|
||||
image: str(row.Image),
|
||||
state: str(row.State),
|
||||
status: str(row.Status),
|
||||
health: str(row.Health),
|
||||
ports,
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
function stateOf(running: number, paused: number, total: number): StackState {
|
||||
if (total === 0) return "not-deployed";
|
||||
if (paused === total) return "paused";
|
||||
if (running === total) return "running";
|
||||
if (running > 0) return "partial";
|
||||
return "stopped";
|
||||
}
|
||||
|
||||
/** Turns the `compose ls` status text ("running(2), exited(1)") into a state. */
|
||||
export function parseStackStatus(status: string): {
|
||||
state: StackState;
|
||||
running: number;
|
||||
total: number;
|
||||
} {
|
||||
let running = 0;
|
||||
let paused = 0;
|
||||
let total = 0;
|
||||
for (const part of status.split(",")) {
|
||||
const match = part.trim().match(/^([a-z]+)\((\d+)\)$/i);
|
||||
if (!match) continue;
|
||||
const count = Number(match[2]);
|
||||
total += count;
|
||||
if (match[1] === "running") running += count;
|
||||
if (match[1] === "paused") paused += count;
|
||||
}
|
||||
return { state: stateOf(running, paused, total), running, total };
|
||||
}
|
||||
|
||||
export function stackStateFromServices(services: StackService[]) {
|
||||
const total = services.length;
|
||||
const running = services.filter((s) => s.state === "running").length;
|
||||
const paused = services.filter((s) => s.state === "paused").length;
|
||||
return { state: stateOf(running, paused, total), running, total };
|
||||
}
|
||||
|
||||
/** Stacks from `compose ls -a --format json`, for hosts with no stacks folder. */
|
||||
export function parseComposeProjects(output: string): StackSummary[] {
|
||||
return parseJsonLines(output)
|
||||
.flatMap((project) => {
|
||||
const name = str(project.Name);
|
||||
if (!STACK_NAME_RE.test(name)) return [];
|
||||
return [
|
||||
{
|
||||
name,
|
||||
managed: false,
|
||||
...parseStackStatus(str(project.Status)),
|
||||
composeFile: str(project.ConfigFiles).split(",")[0] || null,
|
||||
},
|
||||
];
|
||||
})
|
||||
.sort((a, b) => a.name.localeCompare(b.name));
|
||||
}
|
||||
|
||||
/** The compose commands one action runs, in order. */
|
||||
export function composeArgsFor(
|
||||
action: StackAction,
|
||||
service: string | undefined,
|
||||
options: { removeVolumes?: boolean },
|
||||
): string[] {
|
||||
const target = service ? ` ${service}` : "";
|
||||
switch (action) {
|
||||
case "deploy":
|
||||
return [`up -d --remove-orphans${target}`];
|
||||
case "redeploy":
|
||||
return [`pull${target}`, `up -d --remove-orphans${target}`];
|
||||
case "pull":
|
||||
return [`pull${target}`];
|
||||
case "start":
|
||||
case "stop":
|
||||
case "restart":
|
||||
case "pause":
|
||||
case "unpause":
|
||||
return [`${action}${target}`];
|
||||
case "down":
|
||||
return ["down --remove-orphans"];
|
||||
case "destroy":
|
||||
return [`down --remove-orphans${options.removeVolumes ? " -v" : ""}`];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
/**
|
||||
* Host scripts: command builders and output parsers for Docker, Linux
|
||||
* metrics, systemd, the journal and OpenRC.
|
||||
*
|
||||
* Pure TypeScript with no Node or ssh2 imports, so the same code runs in a
|
||||
* plugin backend and in the mobile app. Run a script by sending it on stdin
|
||||
* to the command from `scriptShell()`.
|
||||
*/
|
||||
export * from "./text.js";
|
||||
export * from "./shell.js";
|
||||
export * from "./docker.js";
|
||||
export * from "./metrics.js";
|
||||
export * from "./systemd.js";
|
||||
export * from "./journal.js";
|
||||
export * from "./openrc.js";
|
||||
@@ -0,0 +1,242 @@
|
||||
/** journalctl scripts and parsers. */
|
||||
import { isUnit } from "./systemd.js";
|
||||
import { HostScriptError, shellQuote as q, utf8Decode } from "./text.js";
|
||||
|
||||
export const MAX_JOURNAL_LINES = 5000;
|
||||
const FIELDS = "MESSAGE,PRIORITY,_SYSTEMD_UNIT,SYSLOG_IDENTIFIER,_PID,_COMM";
|
||||
|
||||
export interface JournalQuery {
|
||||
units: string[];
|
||||
priority?: number;
|
||||
since?: string;
|
||||
until?: string;
|
||||
boot?: string;
|
||||
grep?: string;
|
||||
lines: number;
|
||||
kernel: boolean;
|
||||
}
|
||||
|
||||
export interface JournalEntry {
|
||||
/** Unix ms. */
|
||||
time: number;
|
||||
priority: number;
|
||||
unit: string;
|
||||
ident: string;
|
||||
pid: string;
|
||||
message: string;
|
||||
}
|
||||
|
||||
export interface BootView {
|
||||
offset: number;
|
||||
id: string;
|
||||
first: string;
|
||||
last: string;
|
||||
}
|
||||
|
||||
const RELATIVE_RE = /^-\d{1,5}(s|m|min|h|d|w)$/;
|
||||
const DATE_RE = /^\d{4}-\d{2}-\d{2}( \d{2}:\d{2}(:\d{2})?)?$/;
|
||||
const WORDS = ["today", "yesterday", "now"];
|
||||
|
||||
export function isJournalTime(value: string): boolean {
|
||||
return (
|
||||
RELATIVE_RE.test(value) || DATE_RE.test(value) || WORDS.includes(value)
|
||||
);
|
||||
}
|
||||
|
||||
function str(value: unknown): string {
|
||||
return typeof value === "string" ? value.trim() : "";
|
||||
}
|
||||
|
||||
/** Reads journal filters from a query string. Anything odd throws a HostScriptError. */
|
||||
export function parseJournalQuery(
|
||||
input: Record<string, unknown>,
|
||||
): JournalQuery {
|
||||
const rawUnits = Array.isArray(input.unit) ? input.unit : [input.unit];
|
||||
const units = rawUnits.map(str).filter(Boolean);
|
||||
for (const unit of units) {
|
||||
if (!isUnit(unit))
|
||||
throw new HostScriptError("That is not a valid unit name");
|
||||
}
|
||||
if (units.length > 20) throw new HostScriptError("Too many units");
|
||||
|
||||
const query: JournalQuery = {
|
||||
units,
|
||||
lines: 300,
|
||||
kernel: input.kernel === "true" || input.kernel === true,
|
||||
};
|
||||
const priority = str(input.priority);
|
||||
if (priority) {
|
||||
const value = Number(priority);
|
||||
if (!Number.isInteger(value) || value < 0 || value > 7) {
|
||||
throw new HostScriptError("priority must be 0 to 7");
|
||||
}
|
||||
query.priority = value;
|
||||
}
|
||||
for (const key of ["since", "until"] as const) {
|
||||
const value = str(input[key]);
|
||||
if (!value) continue;
|
||||
if (!isJournalTime(value))
|
||||
throw new HostScriptError(`${key} is not a valid time`);
|
||||
query[key] = value;
|
||||
}
|
||||
const boot = str(input.boot);
|
||||
if (boot) {
|
||||
if (!/^(-?\d{1,4}|[0-9a-f]{32})$/.test(boot))
|
||||
throw new HostScriptError("boot is not valid");
|
||||
query.boot = boot;
|
||||
}
|
||||
const grep = typeof input.grep === "string" ? input.grep : "";
|
||||
if (grep) {
|
||||
if (grep.length > 200 || /[\r\n\0]/.test(grep)) {
|
||||
throw new HostScriptError("The search is too long");
|
||||
}
|
||||
query.grep = grep;
|
||||
}
|
||||
const lines = Number(str(input.lines) || 300);
|
||||
if (Number.isFinite(lines) && lines > 0) {
|
||||
query.lines = Math.min(MAX_JOURNAL_LINES, Math.round(lines));
|
||||
}
|
||||
return query;
|
||||
}
|
||||
|
||||
/** journalctl arguments for a query, each one quoted. */
|
||||
export function journalArgs(
|
||||
query: Omit<JournalQuery, "lines"> & { lines?: number },
|
||||
options: { follow?: boolean; useGrep?: boolean } = {},
|
||||
): string {
|
||||
const args = ["journalctl", "--no-pager", "-q", "-o", "json"];
|
||||
args.push(`--output-fields=${FIELDS}`);
|
||||
if (options.follow) args.push("-f");
|
||||
if (query.lines) args.push("-n", String(Math.floor(query.lines)));
|
||||
for (const unit of query.units) {
|
||||
if (!isUnit(unit))
|
||||
throw new HostScriptError("That is not a valid unit name");
|
||||
args.push("-u", q(unit));
|
||||
}
|
||||
if (query.kernel) args.push("-k");
|
||||
if (query.priority !== undefined)
|
||||
args.push("-p", String(Math.floor(query.priority)));
|
||||
if (query.since) args.push("--since", q(query.since));
|
||||
if (query.until) args.push("--until", q(query.until));
|
||||
if (query.boot) args.push("-b", q(query.boot));
|
||||
if (query.grep && options.useGrep !== false) {
|
||||
args.push("--case-sensitive=false", "-g", q(query.grep));
|
||||
}
|
||||
return args.join(" ");
|
||||
}
|
||||
|
||||
export function journalScript(query: JournalQuery): string {
|
||||
// Older journalctl builds have no -g. Then the search runs on our side instead.
|
||||
const noGrep = journalArgs(
|
||||
{ ...query, lines: query.grep ? MAX_JOURNAL_LINES : query.lines },
|
||||
{ useGrep: false },
|
||||
);
|
||||
return `
|
||||
command -v journalctl >/dev/null 2>&1 || { echo "SCRIPT_ERR:This host has no journal"; exit 1; }
|
||||
${journalArgs(query)} 2>/tmp/termix-journal.$$
|
||||
RC=$?
|
||||
if [ $RC -ne 0 ] && grep -qi "pattern" /tmp/termix-journal.$$; then
|
||||
rm -f /tmp/termix-journal.$$
|
||||
echo "@@TERMIX_NOGREP@@"
|
||||
${noGrep}
|
||||
exit 0
|
||||
fi
|
||||
cat /tmp/termix-journal.$$ >&2; rm -f /tmp/termix-journal.$$
|
||||
exit $RC
|
||||
`;
|
||||
}
|
||||
|
||||
function messageOf(value: unknown): string {
|
||||
if (typeof value === "string") return value;
|
||||
if (Array.isArray(value)) {
|
||||
return utf8Decode(value.filter((n): n is number => typeof n === "number"));
|
||||
}
|
||||
return value == null ? "" : String(value);
|
||||
}
|
||||
|
||||
/** One `journalctl -o json` line, or null when it is not an entry. */
|
||||
export function parseEntry(line: string): JournalEntry | null {
|
||||
const text = line.trim();
|
||||
if (!text.startsWith("{")) return null;
|
||||
let raw: Record<string, unknown>;
|
||||
try {
|
||||
raw = JSON.parse(text) as Record<string, unknown>;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
const micros = Number(raw.__REALTIME_TIMESTAMP);
|
||||
const priority = Number(raw.PRIORITY);
|
||||
return {
|
||||
time: Number.isFinite(micros) ? Math.floor(micros / 1000) : 0,
|
||||
priority: Number.isInteger(priority) ? priority : 6,
|
||||
unit: messageOf(raw._SYSTEMD_UNIT),
|
||||
ident: messageOf(raw.SYSLOG_IDENTIFIER ?? raw._COMM),
|
||||
pid: messageOf(raw._PID),
|
||||
message: messageOf(raw.MESSAGE),
|
||||
};
|
||||
}
|
||||
|
||||
export function parseJournal(
|
||||
output: string,
|
||||
query: JournalQuery,
|
||||
): JournalEntry[] {
|
||||
const fallback = output.includes("@@TERMIX_NOGREP@@");
|
||||
const body = fallback ? output.split("@@TERMIX_NOGREP@@")[1] : output;
|
||||
let entries = body
|
||||
.split("\n")
|
||||
.map(parseEntry)
|
||||
.filter((entry): entry is JournalEntry => entry !== null);
|
||||
if (fallback && query.grep) {
|
||||
const needle = query.grep.toLowerCase();
|
||||
entries = entries
|
||||
.filter((entry) => entry.message.toLowerCase().includes(needle))
|
||||
.slice(-query.lines);
|
||||
}
|
||||
return entries;
|
||||
}
|
||||
|
||||
export const BOOTS_SCRIPT = `journalctl --list-boots --no-pager 2>/dev/null | tail -n 50; exit 0\n`;
|
||||
|
||||
export function parseBoots(output: string): BootView[] {
|
||||
const boots: BootView[] = [];
|
||||
for (const line of output.split("\n")) {
|
||||
const match =
|
||||
/^\s*(-?\d+)\s+([0-9a-f]{32})\s+(\w{3} \S+ \S+ \S+)\s*.?\s*(\w{3} \S+ \S+ \S+)?/.exec(
|
||||
line,
|
||||
);
|
||||
if (!match) continue;
|
||||
boots.push({
|
||||
offset: Number(match[1]),
|
||||
id: match[2],
|
||||
first: match[3],
|
||||
last: match[4] ?? "",
|
||||
});
|
||||
}
|
||||
return boots.reverse();
|
||||
}
|
||||
|
||||
export const USAGE_SCRIPT = `journalctl --disk-usage 2>&1; exit 0\n`;
|
||||
|
||||
export function parseUsage(output: string): string {
|
||||
return /take up (\S+)/.exec(output)?.[1] ?? "";
|
||||
}
|
||||
|
||||
const SIZE_RE = /^\d{1,6}(K|M|G)$/;
|
||||
const AGE_RE = /^\d{1,4}(d|w|month|months|year|years)$/;
|
||||
|
||||
export function vacuumScript(body: Record<string, unknown>): string {
|
||||
const size = str(body.size);
|
||||
const time = str(body.time);
|
||||
if (!size && !time) throw new HostScriptError("Give a size or an age");
|
||||
if (size && !SIZE_RE.test(size))
|
||||
throw new HostScriptError("Size looks like 500M or 2G");
|
||||
if (time && !AGE_RE.test(time))
|
||||
throw new HostScriptError("Age looks like 7d or 4w");
|
||||
const flags = [
|
||||
size ? `--vacuum-size=${size}` : "",
|
||||
time ? `--vacuum-time=${time}` : "",
|
||||
]
|
||||
.filter(Boolean)
|
||||
.join(" ");
|
||||
return `journalctl ${flags} 2>&1 || { echo "SCRIPT_ERR:journalctl vacuum failed"; exit 1; }\n`;
|
||||
}
|
||||
@@ -0,0 +1,433 @@
|
||||
/**
|
||||
* Linux metrics: one awk sample of /proc for CPU, memory, load, network and
|
||||
* processes, plus df parsing for disks.
|
||||
*/
|
||||
|
||||
// One awk reads every /proc file itself, so a sample is one exec of awk instead
|
||||
// of a shell plus six tools. Output sections are split by @@; each process line
|
||||
// is pid, utime+stime ticks, rss pages, starttime, state, ppid, comm.
|
||||
const AWK = String.raw`BEGIN{f="/proc/stat";while((getline l<f)>0)if(l~/^cpu/)print l;close(f);print "@@";f="/proc/meminfo";while((getline l<f)>0)if(l~/^(MemTotal|MemFree|MemAvailable|Buffers|Cached|SwapTotal|SwapFree):/)print l;close(f);print "@@";f="/proc/loadavg";getline l<f;print l;close(f);f="/proc/uptime";getline l<f;print l;close(f);print "@@";f="/proc/net/dev";while((getline l<f)>0)print l;close(f);print "@@";print pg;print "@@";for(i=1;i<ARGC;i++){f=ARGV[i];if((getline s<f)>0){a=index(s,"(");if(a&&match(s,/\)[^)]*$/)){split(substr(s,RSTART+2),x," ");print substr(s,1,a-2)" "(x[12]+x[13])" "x[22]"\t"x[20]"\t"x[1]" "x[2]" "substr(s,a+1,RSTART-a-1)}}close(f)}}`;
|
||||
|
||||
/** The live sample command. The page size never changes on a host, so pass it back once known. */
|
||||
export const liveCmd = (pageBytes?: number) =>
|
||||
"awk -v pg=" +
|
||||
(pageBytes ?? '"$(getconf PAGESIZE)"') +
|
||||
" '" +
|
||||
AWK +
|
||||
"' /proc/[0-9]*/stat";
|
||||
|
||||
export interface LiveSample {
|
||||
/** The admin minimum between samples; the client never polls faster. */
|
||||
minIntervalS?: number;
|
||||
cpu: number | null;
|
||||
cpuMix?: { user: number; system: number; iowait: number; steal: number };
|
||||
cores: Array<number | null>;
|
||||
coreIds: string[];
|
||||
memTotalKb: number;
|
||||
memCachedKb: number;
|
||||
memFreeKb: number;
|
||||
memUsedKb: number;
|
||||
swapTotalKb: number;
|
||||
swapUsedKb: number;
|
||||
load: [number, number, number];
|
||||
net: Array<{ name: string; rxBps: number | null; txBps: number | null }>;
|
||||
count: number;
|
||||
running: number;
|
||||
procs: Array<{
|
||||
pid: number;
|
||||
name: string;
|
||||
cpu: number;
|
||||
memKb: number;
|
||||
state: string;
|
||||
ppid: number;
|
||||
}>;
|
||||
/** Seconds since boot. */
|
||||
uptime?: number;
|
||||
/** Total bytes received and sent on every interface but lo, since boot. */
|
||||
netTotals?: { rx: number; tx: number };
|
||||
}
|
||||
|
||||
/** What the next call needs from this one. */
|
||||
export interface LivePrev {
|
||||
at: number;
|
||||
uptime: number;
|
||||
pageBytes: number;
|
||||
cpu: Map<string, { total: number; idle: number }>;
|
||||
/** Aggregate user nice system idle iowait irq softirq steal ticks, for the breakdown. */
|
||||
cpuRaw?: number[];
|
||||
/** Keyed by pid:starttime so a reused pid never inherits another process's ticks. */
|
||||
ticks: Map<string, number>;
|
||||
net: Map<string, { rx: number; tx: number }>;
|
||||
}
|
||||
|
||||
/** Total and idle ticks from a /proc/stat `cpu` line. */
|
||||
export function parseCpuLine(
|
||||
cpuLine: string,
|
||||
): { total: number; idle: number } | undefined {
|
||||
const parts = cpuLine.trim().split(/\s+/);
|
||||
if (parts[0] !== "cpu") return undefined;
|
||||
const nums = parts
|
||||
.slice(1)
|
||||
.map((n) => Number(n))
|
||||
.filter((n) => Number.isFinite(n));
|
||||
if (nums.length < 4) return undefined;
|
||||
const idle = (nums[3] ?? 0) + (nums[4] ?? 0);
|
||||
const total = nums.reduce((a, b) => a + b, 0);
|
||||
return { total, idle };
|
||||
}
|
||||
|
||||
const TOP_N = 60;
|
||||
|
||||
/** Parses `liveCmd()` output. Rates need the `next` of the previous call. */
|
||||
export function parseLive(
|
||||
output: string,
|
||||
prev: LivePrev | undefined,
|
||||
at = Date.now(),
|
||||
): { sample: LiveSample; next: LivePrev } {
|
||||
const [cpuS = "", memS = "", loadS = "", netS = "", pageS = "", procS = ""] =
|
||||
output.split("@@\n");
|
||||
|
||||
// Only the first 8 fields: guest and guest_nice are already inside user and nice.
|
||||
const cpu = new Map<string, { total: number; idle: number }>();
|
||||
let cpuRaw: number[] | undefined;
|
||||
for (const l of cpuS.split("\n")) {
|
||||
const name = l.split(/\s+/)[0];
|
||||
if (!name.startsWith("cpu")) continue;
|
||||
if (name === "cpu") cpuRaw = l.split(/\s+/).slice(1, 9).map(Number);
|
||||
const c = parseCpuLine(
|
||||
l
|
||||
.replace(/^cpu\d*/, "cpu")
|
||||
.split(/\s+/)
|
||||
.slice(0, 9)
|
||||
.join(" "),
|
||||
);
|
||||
if (c) cpu.set(name, c);
|
||||
}
|
||||
// Matched by name, so an offline core does not shift the ones after it.
|
||||
const pct = (name: string) => {
|
||||
const p = prev?.cpu.get(name);
|
||||
const c = cpu.get(name);
|
||||
if (!p || !c || c.total <= p.total) return null;
|
||||
const used = c.total - p.total - (c.idle - p.idle);
|
||||
return Math.max(0, Math.min(100, (used / (c.total - p.total)) * 100));
|
||||
};
|
||||
|
||||
// Where the busy time went since the last sample, as percent of all ticks.
|
||||
let cpuMix: LiveSample["cpuMix"];
|
||||
if (prev?.cpuRaw && cpuRaw && cpuRaw.length === 8) {
|
||||
const d = cpuRaw.map((v, i) => v - (prev.cpuRaw?.[i] ?? 0));
|
||||
const total = d.reduce((a, b) => a + b, 0);
|
||||
if (total > 0 && d.every((v) => v >= 0)) {
|
||||
const p = (n: number) => (n / total) * 100;
|
||||
cpuMix = {
|
||||
user: p(d[0] + d[1]),
|
||||
system: p(d[2] + d[5] + d[6]),
|
||||
iowait: p(d[4]),
|
||||
steal: p(d[7]),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
const mem: Record<string, number> = {};
|
||||
for (const l of memS.split("\n")) {
|
||||
const m = l.match(/^(\w+):\s+(\d+)/);
|
||||
if (m) mem[m[1]] = Number(m[2]);
|
||||
}
|
||||
|
||||
const [la = "", up = ""] = loadS.trim().split("\n");
|
||||
const laParts = la.split(/\s+/).map(Number);
|
||||
const uptime = Number(up.split(/\s+/)[0]) || 0;
|
||||
|
||||
const nets = new Map<string, { rx: number; tx: number }>();
|
||||
for (const l of netS.split("\n")) {
|
||||
const [name, rest] = l.split(":");
|
||||
if (!rest || name.trim() === "lo") continue;
|
||||
const f = rest.trim().split(/\s+/);
|
||||
nets.set(name.trim(), { rx: Number(f[0]) || 0, tx: Number(f[8]) || 0 });
|
||||
}
|
||||
// A reboot makes uptime go backwards, so rates start again.
|
||||
const dt = prev && uptime > prev.uptime ? uptime - prev.uptime : 0;
|
||||
const rate = (now: number, before: number | undefined) =>
|
||||
dt > 0 && before !== undefined && now >= before
|
||||
? (now - before) / dt
|
||||
: null;
|
||||
|
||||
const pageBytes = Number(pageS.trim()) || prev?.pageBytes || 4096;
|
||||
const pageKb = pageBytes / 1024;
|
||||
const aggDelta =
|
||||
prev && cpu.has("cpu") && prev.cpu.has("cpu")
|
||||
? cpu.get("cpu")!.total - prev.cpu.get("cpu")!.total
|
||||
: 0;
|
||||
const cores = [...cpu.keys()].filter((k) => k !== "cpu");
|
||||
const ncpu = Math.max(1, cores.length);
|
||||
const ticks = new Map<string, number>();
|
||||
const procs: LiveSample["procs"] = [];
|
||||
for (const l of procS.split("\n")) {
|
||||
const [pid, t, rss, start, state, ppid, ...rest] = l.split("\t");
|
||||
const name = rest.join("\t");
|
||||
if (!name) continue;
|
||||
const key = pid + ":" + start;
|
||||
const tk = Number(t) || 0;
|
||||
ticks.set(key, tk);
|
||||
const before = prev?.ticks.get(key);
|
||||
procs.push({
|
||||
pid: Number(pid),
|
||||
name,
|
||||
cpu:
|
||||
before !== undefined && aggDelta > 0 && tk >= before
|
||||
? ((tk - before) / aggDelta) * ncpu * 100
|
||||
: 0,
|
||||
memKb: (Number(rss) || 0) * pageKb,
|
||||
state: state || "?",
|
||||
ppid: Number(ppid) || 0,
|
||||
});
|
||||
}
|
||||
procs.sort((a, b) => b.cpu - a.cpu || b.memKb - a.memKb);
|
||||
|
||||
// Awk exits 0 when /proc is missing (macOS, restricted containers); that is not a sample.
|
||||
if (!cpu.has("cpu") || !mem.MemTotal || !uptime) {
|
||||
throw new Error("live sample unavailable: /proc data missing");
|
||||
}
|
||||
const memTotalKb = mem.MemTotal;
|
||||
const swapTotalKb = mem.SwapTotal ?? 0;
|
||||
let rxTotal = 0;
|
||||
let txTotal = 0;
|
||||
for (const c of nets.values()) {
|
||||
rxTotal += c.rx;
|
||||
txTotal += c.tx;
|
||||
}
|
||||
return {
|
||||
sample: {
|
||||
cpu: pct("cpu"),
|
||||
cores: cores.map(pct),
|
||||
coreIds: cores.map((k) => k.slice(3)),
|
||||
cpuMix,
|
||||
memTotalKb,
|
||||
memCachedKb: (mem.Buffers ?? 0) + (mem.Cached ?? 0),
|
||||
memFreeKb: mem.MemFree ?? 0,
|
||||
memUsedKb: memTotalKb - (mem.MemAvailable ?? 0),
|
||||
swapTotalKb,
|
||||
swapUsedKb: swapTotalKb - (mem.SwapFree ?? 0),
|
||||
load: [laParts[0] || 0, laParts[1] || 0, laParts[2] || 0],
|
||||
net: [...nets].map(([name, c]) => ({
|
||||
name,
|
||||
rxBps: rate(c.rx, prev?.net.get(name)?.rx),
|
||||
txBps: rate(c.tx, prev?.net.get(name)?.tx),
|
||||
})),
|
||||
count: procs.length,
|
||||
running: procs.filter((p) => p.state === "R").length,
|
||||
procs: procs.slice(0, TOP_N),
|
||||
uptime,
|
||||
netTotals: { rx: rxTotal, tx: txTotal },
|
||||
},
|
||||
next: { at, uptime, pageBytes, cpu, cpuRaw, ticks, net: nets },
|
||||
};
|
||||
}
|
||||
|
||||
// Disks
|
||||
|
||||
const DARWIN_DATA_MOUNT = "/System/Volumes/Data";
|
||||
const PSEUDO_FS_RE =
|
||||
/^(tmpfs|devtmpfs|overlay|udev|none|shm|squashfs|efivarfs)$/;
|
||||
|
||||
/** GNU df sizes in KiB, without the header. */
|
||||
export const DF_BYTES_COMMAND = "df -TkP | tail -n +2";
|
||||
/** GNU df sizes as short human text, without the header. */
|
||||
export const DF_HUMAN_COMMAND = "df -hT -P | tail -n +2";
|
||||
|
||||
export interface DfRow {
|
||||
filesystem: string;
|
||||
type: string;
|
||||
mount: string;
|
||||
parts: string[];
|
||||
}
|
||||
|
||||
export interface DiskFilesystem {
|
||||
filesystem: string;
|
||||
type: string;
|
||||
mount: string;
|
||||
percent: number | null;
|
||||
usedHuman: string | null;
|
||||
totalHuman: string | null;
|
||||
availableHuman: string | null;
|
||||
usedBytes: number | null;
|
||||
totalBytes: number | null;
|
||||
availableBytes: number | null;
|
||||
label?: string;
|
||||
}
|
||||
|
||||
export interface MonitoredMount {
|
||||
path: string;
|
||||
label?: string;
|
||||
}
|
||||
|
||||
function toFixedNum(n: number | null | undefined, digits = 2): number | null {
|
||||
if (typeof n !== "number" || !Number.isFinite(n)) return null;
|
||||
return Number(n.toFixed(digits));
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses `df -T -P` style output: Filesystem, Type, then the size columns,
|
||||
* with Mounted-on last. Pseudo filesystems are left out.
|
||||
*/
|
||||
export function parseDfLines(output: string): DfRow[] {
|
||||
return output
|
||||
.split("\n")
|
||||
.map((l) => l.trim())
|
||||
.filter(Boolean)
|
||||
.map((line) => {
|
||||
const parts = line.split(/\s+/);
|
||||
return {
|
||||
filesystem: parts[0] || "",
|
||||
type: parts[1] || "",
|
||||
mount: parts[6] || "",
|
||||
parts,
|
||||
};
|
||||
})
|
||||
.filter((row) => row.parts.length >= 7 && !PSEUDO_FS_RE.test(row.type));
|
||||
}
|
||||
|
||||
/** The most used real filesystem in a `df -TkP` row set. */
|
||||
export function findWorstMountIndex(bytesRows: DfRow[]): {
|
||||
index: number;
|
||||
usedBytes: number;
|
||||
totalBytes: number;
|
||||
} {
|
||||
let worstIndex = -1;
|
||||
let worstUsedBytes = -1;
|
||||
let worstTotalBytes = 0;
|
||||
bytesRows.forEach((row, index) => {
|
||||
const totalBytes = Number(row.parts[2]);
|
||||
const usedBytes = Number(row.parts[3]);
|
||||
if (
|
||||
!Number.isFinite(totalBytes) ||
|
||||
!Number.isFinite(usedBytes) ||
|
||||
totalBytes <= 0
|
||||
) {
|
||||
return;
|
||||
}
|
||||
const usedRatio = usedBytes / totalBytes;
|
||||
const worstRatio =
|
||||
worstTotalBytes > 0 ? worstUsedBytes / worstTotalBytes : -1;
|
||||
if (usedRatio > worstRatio) {
|
||||
worstIndex = index;
|
||||
worstUsedBytes = usedBytes;
|
||||
worstTotalBytes = totalBytes;
|
||||
}
|
||||
});
|
||||
return {
|
||||
index: worstIndex,
|
||||
usedBytes: worstUsedBytes,
|
||||
totalBytes: worstTotalBytes,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Merges `df -TkP` size rows (parts[2..4] in `blockSizeBytes` units) and
|
||||
* `df -hT -P` human rows into one list. Human rows only supply the display
|
||||
* text, matched by mount point so a mismatched row count can't shift them.
|
||||
*/
|
||||
export function buildFilesystemList(
|
||||
bytesRows: DfRow[],
|
||||
humanRows: DfRow[],
|
||||
blockSizeBytes = 1,
|
||||
): DiskFilesystem[] {
|
||||
const aligned = humanRows.length === bytesRows.length;
|
||||
return bytesRows
|
||||
.map((row, index) => {
|
||||
const totalBytes = Number(row.parts[2]) * blockSizeBytes;
|
||||
const usedBytes = Number(row.parts[3]) * blockSizeBytes;
|
||||
const availableBytes = Number(row.parts[4]) * blockSizeBytes;
|
||||
if (!Number.isFinite(totalBytes) || totalBytes <= 0) return null;
|
||||
const humanRow = aligned
|
||||
? humanRows[index]
|
||||
: humanRows.find((h) => h.mount === row.mount);
|
||||
const percent = Number.isFinite(usedBytes)
|
||||
? Math.max(0, Math.min(100, (usedBytes / totalBytes) * 100))
|
||||
: null;
|
||||
return {
|
||||
filesystem: row.filesystem,
|
||||
type: row.type,
|
||||
mount: row.mount,
|
||||
percent: toFixedNum(percent, 0),
|
||||
usedHuman: humanRow?.parts[3] || null,
|
||||
totalHuman: humanRow?.parts[2] || null,
|
||||
availableHuman: humanRow?.parts[4] || null,
|
||||
usedBytes: Number.isFinite(usedBytes) ? usedBytes : null,
|
||||
totalBytes,
|
||||
availableBytes: Number.isFinite(availableBytes) ? availableBytes : null,
|
||||
};
|
||||
})
|
||||
.filter((fs): fs is DiskFilesystem => fs !== null);
|
||||
}
|
||||
|
||||
/**
|
||||
* The headline disk is the root filesystem. On macOS "/" is the small sealed
|
||||
* system volume, so the data volume wins there. With no root mount the most
|
||||
* used one is shown.
|
||||
*/
|
||||
export function selectPrimaryFilesystem(
|
||||
filesystems: DiskFilesystem[],
|
||||
): DiskFilesystem | null {
|
||||
if (filesystems.length === 0) return null;
|
||||
const root =
|
||||
filesystems.find((fs) => fs.mount === DARWIN_DATA_MOUNT) ??
|
||||
filesystems.find((fs) => fs.mount === "/");
|
||||
if (root) return root;
|
||||
let best = filesystems[0];
|
||||
for (const fs of filesystems) {
|
||||
const ratio = (fs.usedBytes ?? 0) / (fs.totalBytes || 1);
|
||||
const bestRatio = (best.usedBytes ?? 0) / (best.totalBytes || 1);
|
||||
if (ratio > bestRatio) best = fs;
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
/**
|
||||
* Drops mounts by exact path ("/mnt/nas") or by filesystem type substring
|
||||
* ("nfs" matches nfs and nfs4), so network shares can be hidden.
|
||||
*/
|
||||
export function filterExcludedFilesystems(
|
||||
filesystems: DiskFilesystem[],
|
||||
excludedMounts?: string[] | null,
|
||||
): DiskFilesystem[] {
|
||||
if (!excludedMounts || excludedMounts.length === 0) return filesystems;
|
||||
const normalized = excludedMounts
|
||||
.map((entry) => entry.trim().toLowerCase())
|
||||
.filter(Boolean);
|
||||
if (normalized.length === 0) return filesystems;
|
||||
return filesystems.filter((fs) => {
|
||||
const mount = fs.mount.toLowerCase();
|
||||
const type = fs.type.toLowerCase();
|
||||
return !normalized.some(
|
||||
(entry) => mount === entry || (type && type.includes(entry)),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
export function mergeMonitoredFilesystems(
|
||||
filesystems: DiskFilesystem[],
|
||||
monitored: MonitoredMount[],
|
||||
customFilesystems: Array<DiskFilesystem | null>,
|
||||
): DiskFilesystem[] {
|
||||
const result = [...filesystems];
|
||||
monitored.forEach((entry, index) => {
|
||||
const path = entry.path.trim();
|
||||
const custom = customFilesystems[index];
|
||||
if (!path || !custom) return;
|
||||
const existing = result.find((fs) => fs.mount === path);
|
||||
if (existing) {
|
||||
existing.label = entry.label?.trim() || undefined;
|
||||
return;
|
||||
}
|
||||
result.push({
|
||||
...custom,
|
||||
mount: path,
|
||||
label: entry.label?.trim() || undefined,
|
||||
});
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
/** Host name, OS, kernel and arch in one exec, as key=value lines. */
|
||||
export const SYSTEM_INFO_COMMAND = `echo "hostname=$(hostname 2>/dev/null || cat /etc/hostname 2>/dev/null)"; echo "os=$( . /etc/os-release 2>/dev/null; echo "$PRETTY_NAME")"; echo "kernel=$(uname -r 2>/dev/null)"; echo "arch=$(uname -m 2>/dev/null)"`;
|
||||
@@ -0,0 +1,94 @@
|
||||
/** OpenRC scripts, with states mapped onto the words systemd uses. */
|
||||
import { isOpenRcName, type UnitAction, type UnitSummary } from "./systemd.js";
|
||||
import { HostScriptError, shellQuote as q } from "./text.js";
|
||||
|
||||
export const OPENRC_LIST_SCRIPT = `
|
||||
rc-status --servicelist 2>/dev/null
|
||||
echo "@@TERMIX_RUNLEVELS@@"
|
||||
rc-update show -v 2>/dev/null
|
||||
exit 0
|
||||
`;
|
||||
|
||||
function activeOf(state: string): { active: string; sub: string } {
|
||||
switch (state) {
|
||||
case "started":
|
||||
return { active: "active", sub: "running" };
|
||||
case "crashed":
|
||||
return { active: "failed", sub: "crashed" };
|
||||
case "starting":
|
||||
return { active: "activating", sub: "starting" };
|
||||
case "stopping":
|
||||
return { active: "deactivating", sub: "stopping" };
|
||||
case "inactive":
|
||||
case "hotplugged":
|
||||
return { active: "inactive", sub: state };
|
||||
default:
|
||||
return { active: "inactive", sub: state || "stopped" };
|
||||
}
|
||||
}
|
||||
|
||||
export function parseOpenRcList(output: string): UnitSummary[] {
|
||||
const [list = "", levels = ""] = output.split("@@TERMIX_RUNLEVELS@@");
|
||||
const units = new Map<string, UnitSummary>();
|
||||
for (const line of list.split("\n")) {
|
||||
const match = /^\s*(\S+)\s+\[\s*([a-z ]+?)\s*\]/.exec(line);
|
||||
if (!match) continue;
|
||||
const { active, sub } = activeOf(match[2]);
|
||||
units.set(match[1], {
|
||||
name: match[1],
|
||||
type: "service",
|
||||
load: "loaded",
|
||||
active,
|
||||
sub,
|
||||
description: "",
|
||||
fileState: "disabled",
|
||||
preset: "",
|
||||
});
|
||||
}
|
||||
for (const line of levels.split("\n")) {
|
||||
const match = /^\s*(\S+)\s*\|\s*(.*)$/.exec(line);
|
||||
if (!match) continue;
|
||||
const runlevels = match[2].trim();
|
||||
const known = units.get(match[1]) ?? {
|
||||
name: match[1],
|
||||
type: "service",
|
||||
load: "loaded",
|
||||
active: "inactive",
|
||||
sub: "stopped",
|
||||
description: "",
|
||||
fileState: "disabled",
|
||||
preset: "",
|
||||
};
|
||||
known.fileState = runlevels ? "enabled" : "disabled";
|
||||
known.description = runlevels ? `Runlevels: ${runlevels}` : "";
|
||||
units.set(match[1], known);
|
||||
}
|
||||
return [...units.values()].sort((a, b) => a.name.localeCompare(b.name));
|
||||
}
|
||||
|
||||
function requireName(name: string): string {
|
||||
if (!isOpenRcName(name))
|
||||
throw new HostScriptError("That is not a valid service name");
|
||||
return name;
|
||||
}
|
||||
|
||||
export function openRcActionScript(name: string, action: UnitAction): string {
|
||||
const s = q(requireName(name));
|
||||
switch (action) {
|
||||
case "start":
|
||||
case "stop":
|
||||
case "restart":
|
||||
return `rc-service ${s} ${action} 2>&1 || { echo "SCRIPT_ERR:rc-service ${action} failed"; exit 1; }\n`;
|
||||
case "enable":
|
||||
return `rc-update add ${s} default 2>&1 || { echo "SCRIPT_ERR:rc-update add failed"; exit 1; }\n`;
|
||||
case "disable":
|
||||
return `rc-update del ${s} 2>&1 || { echo "SCRIPT_ERR:rc-update del failed"; exit 1; }\n`;
|
||||
default:
|
||||
throw new HostScriptError("OpenRC can't do that", 400);
|
||||
}
|
||||
}
|
||||
|
||||
export function openRcStatusScript(name: string): string {
|
||||
const s = q(requireName(name));
|
||||
return `rc-service ${s} status 2>&1; rc-update show -v 2>/dev/null | grep -E '^ *'${s}' *\\|'; exit 0\n`;
|
||||
}
|
||||
@@ -0,0 +1,117 @@
|
||||
/**
|
||||
* How a script reaches the host: the command line runs a shell that reads
|
||||
* the script from stdin (`bash -s`), so names and values in a script are
|
||||
* never parsed out of argv.
|
||||
*/
|
||||
import { shellQuote, toBase64 } from "./text.js";
|
||||
|
||||
// systemctl and friends often live in sbin, which a normal login skips.
|
||||
// TZ=UTC so tools print every time in UTC, which parses the same anywhere.
|
||||
const ENV = "SYSTEMD_COLORS=0 SYSTEMD_PAGER=cat LC_ALL=C TZ=UTC";
|
||||
|
||||
/** Puts sbin on PATH and sets a plain, UTC environment. */
|
||||
export const SCRIPT_PRELUDE = `export PATH="$PATH:/usr/sbin:/sbin:/usr/local/sbin"; export ${ENV}; `;
|
||||
const SUDO = `sudo -n env PATH="$PATH" ${ENV}`;
|
||||
|
||||
/**
|
||||
* - `plain`: the login user.
|
||||
* - `auto`: root when it can be had without a password, else the login user.
|
||||
* - `root`: root or passwordless sudo, fails on anything else.
|
||||
* - `root-only`: root logins only, for hosts where sudo is turned off.
|
||||
*/
|
||||
export type ScriptShellMode = "plain" | "auto" | "root" | "root-only";
|
||||
|
||||
const ERR = "SCRIPT_ERR:";
|
||||
|
||||
/** The command line that runs a script sent on stdin. */
|
||||
export function scriptShell(mode: ScriptShellMode): string {
|
||||
switch (mode) {
|
||||
case "plain":
|
||||
return `${SCRIPT_PRELUDE}exec bash -s`;
|
||||
case "auto":
|
||||
return `${SCRIPT_PRELUDE}if [ "$(id -u)" = "0" ]; then exec bash -s; elif sudo -n true 2>/dev/null; then exec ${SUDO} bash -s; else exec bash -s; fi`;
|
||||
case "root":
|
||||
return `${SCRIPT_PRELUDE}if [ "$(id -u)" = "0" ]; then exec bash -s; else exec ${SUDO} bash -s; fi`;
|
||||
case "root-only":
|
||||
return `${SCRIPT_PRELUDE}if [ "$(id -u)" = "0" ]; then exec bash -s; else echo "${ERR}This needs root, or turn on Use sudo for this host"; exit 1; fi`;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs a script as root with a sudo password. The command is `plain`; all of
|
||||
* the returned stdin goes to the host. The password is read by the first
|
||||
* line into a shell variable and piped to `sudo -S`, so it is never in argv,
|
||||
* never in the environment and never run as a command. Root logins and
|
||||
* passwordless sudo skip the password. The script itself travels as base64.
|
||||
*/
|
||||
export function passwordSudoScript(
|
||||
script: string,
|
||||
password: string,
|
||||
): { command: string; stdin: string } {
|
||||
if (/[\r\n\0]/.test(password)) {
|
||||
throw new Error("A sudo password can't contain a line break");
|
||||
}
|
||||
const run = `bash -c "$TERMIX_S"`;
|
||||
const stdin = `IFS= read -r TERMIX_PW
|
||||
${password}
|
||||
TERMIX_S=$(printf '%s' ${shellQuote(toBase64(script))} | base64 -d)
|
||||
if [ "$(id -u)" = "0" ]; then unset TERMIX_PW; exec ${run}
|
||||
elif sudo -n true 2>/dev/null; then unset TERMIX_PW; exec ${SUDO} ${run}
|
||||
else P=$TERMIX_PW; unset TERMIX_PW; printf '%s\\n' "$P" | sudo -k -S -p '' env PATH="$PATH" ${ENV} ${run}; exit $?
|
||||
fi
|
||||
`;
|
||||
return { command: scriptShell("plain"), stdin };
|
||||
}
|
||||
|
||||
/** sudo asked for a password or a terminal it did not get. */
|
||||
export const SUDO_REFUSED_RE =
|
||||
/password is required|a terminal is required|no tty present/i;
|
||||
/** sudo got a password and it was wrong. */
|
||||
export const SUDO_WRONG_RE =
|
||||
/incorrect password|sorry, try again|no password was provided/i;
|
||||
/** The user may not use sudo at all. */
|
||||
export const NOT_SUDOER_RE =
|
||||
/is not in the sudoers file|not allowed to run sudo/i;
|
||||
|
||||
/**
|
||||
* Scripts print `SCRIPT_ERR:` lines (or the older `SERVICES_ERR:`) before a
|
||||
* non zero exit to explain a failure.
|
||||
*/
|
||||
export function scriptError(stdout: string): string {
|
||||
return stdout
|
||||
.split("\n")
|
||||
.map((line) => {
|
||||
if (line.startsWith(ERR)) return line.slice(ERR.length);
|
||||
if (line.startsWith("SERVICES_ERR:")) return line.slice(13);
|
||||
return null;
|
||||
})
|
||||
.filter((line): line is string => line !== null)
|
||||
.join("\n")
|
||||
.trim();
|
||||
}
|
||||
|
||||
/** A line a script prints to explain why it stops. */
|
||||
export function errLine(message: string): string {
|
||||
return `echo ${shellQuote(ERR + message)}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs a long command in the background and stops it once stdin closes,
|
||||
* which happens when the SSH channel ends. A pty can't be trusted for this:
|
||||
* sudo keeps its own and the command would outlive the viewer.
|
||||
*/
|
||||
export function watchdog(command: string): string {
|
||||
return `${command} &
|
||||
P=$!
|
||||
trap 'kill $P 2>/dev/null' EXIT
|
||||
cat >/dev/null
|
||||
`;
|
||||
}
|
||||
|
||||
/** The wrapper a streamed command runs in, as one shell command line. */
|
||||
export function streamCommand(script: string, sudo: boolean): string {
|
||||
const quoted = shellQuote(`${SCRIPT_PRELUDE}${script}`);
|
||||
return sudo
|
||||
? `if [ "$(id -u)" = "0" ]; then exec bash -c ${quoted}; elif sudo -n true 2>/dev/null; then exec ${SUDO} bash -c ${quoted}; else exec bash -c ${quoted}; fi`
|
||||
: `exec bash -c ${quoted}`;
|
||||
}
|
||||
@@ -0,0 +1,389 @@
|
||||
/**
|
||||
* systemd unit scripts and parsers, plus init system detection.
|
||||
* Every script is meant for `scriptShell()`, sent on stdin.
|
||||
*/
|
||||
import { HostScriptError, parseKeys, shellQuote as q } from "./text.js";
|
||||
|
||||
export const UNIT_TYPES = [
|
||||
"service",
|
||||
"socket",
|
||||
"timer",
|
||||
"target",
|
||||
"mount",
|
||||
"automount",
|
||||
"path",
|
||||
"swap",
|
||||
"slice",
|
||||
"scope",
|
||||
"device",
|
||||
] as const;
|
||||
export type UnitType = (typeof UNIT_TYPES)[number];
|
||||
|
||||
// Backslash is allowed for escaped names like dev-disk-by\x2duuid.
|
||||
const UNIT_RE = new RegExp(
|
||||
`^[A-Za-z0-9_][A-Za-z0-9:_.@\\\\-]{0,250}\\.(${UNIT_TYPES.join("|")})$`,
|
||||
);
|
||||
const OPENRC_RE = /^[A-Za-z0-9_][A-Za-z0-9_.@-]{0,127}$/;
|
||||
|
||||
export function isUnit(name: unknown): name is string {
|
||||
return typeof name === "string" && UNIT_RE.test(name);
|
||||
}
|
||||
|
||||
export function unitType(name: string): UnitType {
|
||||
return name.slice(name.lastIndexOf(".") + 1) as UnitType;
|
||||
}
|
||||
|
||||
/** Units a file may be written for. Templates and device style names are out. */
|
||||
export function isWritableUnitName(name: string): boolean {
|
||||
return (
|
||||
isUnit(name) &&
|
||||
!name.includes("\\") &&
|
||||
["service", "socket", "timer", "target", "path", "mount"].includes(
|
||||
unitType(name),
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
export function isOpenRcName(name: unknown): name is string {
|
||||
return typeof name === "string" && OPENRC_RE.test(name);
|
||||
}
|
||||
|
||||
export function requireUnit(name: unknown): string {
|
||||
if (!isUnit(name)) throw new HostScriptError("That is not a valid unit name");
|
||||
return name;
|
||||
}
|
||||
|
||||
export type InitSystem = "systemd" | "openrc" | "none";
|
||||
|
||||
/** A unit name or, on OpenRC, a service name. */
|
||||
export function requireService(name: unknown, init: string): string {
|
||||
if (init === "openrc") {
|
||||
if (!isOpenRcName(name))
|
||||
throw new HostScriptError("That is not a valid service name");
|
||||
return name;
|
||||
}
|
||||
return requireUnit(name);
|
||||
}
|
||||
|
||||
export interface UnitSummary {
|
||||
name: string;
|
||||
type: string;
|
||||
load: string;
|
||||
active: string;
|
||||
sub: string;
|
||||
description: string;
|
||||
/** enabled, disabled, static, masked and so on. Empty when unknown. */
|
||||
fileState: string;
|
||||
preset: string;
|
||||
}
|
||||
|
||||
export interface UnitDetail {
|
||||
name: string;
|
||||
props: Record<string, string>;
|
||||
status: string;
|
||||
}
|
||||
|
||||
export interface TimerView {
|
||||
name: string;
|
||||
description: string;
|
||||
active: string;
|
||||
fileState: string;
|
||||
/** Unix ms, or null when not set. */
|
||||
next: number | null;
|
||||
last: number | null;
|
||||
activates: string;
|
||||
schedule: string[];
|
||||
}
|
||||
|
||||
export const UNIT_ACTIONS = [
|
||||
"start",
|
||||
"stop",
|
||||
"restart",
|
||||
"reload",
|
||||
"enable",
|
||||
"disable",
|
||||
"enable-now",
|
||||
"disable-now",
|
||||
"mask",
|
||||
"unmask",
|
||||
"reset-failed",
|
||||
"revert",
|
||||
] as const;
|
||||
export type UnitAction = (typeof UNIT_ACTIONS)[number];
|
||||
|
||||
/** Actions OpenRC can do. */
|
||||
export const OPENRC_ACTIONS: readonly UnitAction[] = [
|
||||
"start",
|
||||
"stop",
|
||||
"restart",
|
||||
"enable",
|
||||
"disable",
|
||||
];
|
||||
|
||||
export const DETECT_SCRIPT = `
|
||||
INIT=none
|
||||
if command -v systemctl >/dev/null 2>&1 && [ -d /run/systemd/system ]; then INIT=systemd
|
||||
elif command -v rc-service >/dev/null 2>&1; then INIT=openrc; fi
|
||||
echo "init=$INIT"
|
||||
if [ "$INIT" = systemd ]; then echo "version=$(systemctl --version 2>/dev/null | head -n1 | awk '{print $2}')"; fi
|
||||
if [ "$INIT" = openrc ]; then echo "version=$(openrc --version 2>/dev/null | head -n1 | awk '{print $NF}')"; fi
|
||||
echo "os=$( . /etc/os-release 2>/dev/null; echo "$PRETTY_NAME")"
|
||||
echo "hostname=$(hostname 2>/dev/null || cat /etc/hostname 2>/dev/null)"
|
||||
echo "uid=$(id -u)"
|
||||
if command -v journalctl >/dev/null 2>&1; then echo "journal=1"; fi
|
||||
if [ "$INIT" = systemd ]; then echo "failed=$(systemctl list-units --state=failed --plain --no-legend --no-pager 2>/dev/null | wc -l)"; fi
|
||||
if [ "$INIT" = openrc ]; then echo "failed=$(rc-status --crashed 2>/dev/null | wc -l)"; fi
|
||||
exit 0
|
||||
`;
|
||||
|
||||
export interface Detected {
|
||||
init: InitSystem;
|
||||
version: string;
|
||||
os: string;
|
||||
hostname: string;
|
||||
root: boolean;
|
||||
journal: boolean;
|
||||
failed: number;
|
||||
}
|
||||
|
||||
export function parseDetect(output: string): Detected {
|
||||
const keys = parseKeys(output);
|
||||
const init =
|
||||
keys.init === "systemd" || keys.init === "openrc" ? keys.init : "none";
|
||||
return {
|
||||
init,
|
||||
version: keys.version ?? "",
|
||||
os: keys.os ?? "",
|
||||
hostname: keys.hostname ?? "",
|
||||
root: keys.uid === "0",
|
||||
journal: keys.journal === "1",
|
||||
failed: Number(keys.failed) || 0,
|
||||
};
|
||||
}
|
||||
|
||||
/** Types the list can show. */
|
||||
export const LIST_TYPES = [
|
||||
"service",
|
||||
"socket",
|
||||
"timer",
|
||||
"target",
|
||||
"path",
|
||||
"mount",
|
||||
] as const;
|
||||
export type ListType = (typeof LIST_TYPES)[number] | "all";
|
||||
|
||||
export function listUnitsScript(type: ListType): string {
|
||||
const types = type === "all" ? LIST_TYPES.join(",") : type;
|
||||
if (type !== "all" && !LIST_TYPES.includes(type))
|
||||
throw new HostScriptError("Unknown unit type");
|
||||
return `
|
||||
systemctl list-units --all --plain --no-legend --no-pager --full --type=${types} 2>/dev/null
|
||||
echo "@@TERMIX_FILES@@"
|
||||
systemctl list-unit-files --plain --no-legend --no-pager --full --type=${types} 2>/dev/null
|
||||
exit 0
|
||||
`;
|
||||
}
|
||||
|
||||
/** Merges list-units and list-unit-files. Template units are left out. */
|
||||
export function parseUnitList(output: string): UnitSummary[] {
|
||||
const [loaded = "", files = ""] = output.split("@@TERMIX_FILES@@");
|
||||
const units = new Map<string, UnitSummary>();
|
||||
for (const raw of loaded.split("\n")) {
|
||||
const line = raw.replace(/^[●*\s]+/, "").trimEnd();
|
||||
if (!line) continue;
|
||||
const match = /^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s*(.*)$/.exec(line);
|
||||
if (!match) continue;
|
||||
const [, name, load, active, sub, description] = match;
|
||||
if (!name.includes(".") || name.includes("@.")) continue;
|
||||
units.set(name, {
|
||||
name,
|
||||
type: unitType(name),
|
||||
load,
|
||||
active,
|
||||
sub,
|
||||
description: description.trim(),
|
||||
fileState: "",
|
||||
preset: "",
|
||||
});
|
||||
}
|
||||
for (const raw of files.split("\n")) {
|
||||
const line = raw.trim();
|
||||
if (!line) continue;
|
||||
const [name, state = "", preset = ""] = line.split(/\s+/);
|
||||
if (!name || !name.includes(".") || name.includes("@.")) continue;
|
||||
const known = units.get(name);
|
||||
const cleanPreset = preset === "-" ? "" : preset;
|
||||
if (known) {
|
||||
known.fileState = state;
|
||||
known.preset = cleanPreset;
|
||||
} else {
|
||||
units.set(name, {
|
||||
name,
|
||||
type: unitType(name),
|
||||
load: state === "masked" ? "masked" : "unloaded",
|
||||
active: "inactive",
|
||||
sub: "dead",
|
||||
description: "",
|
||||
fileState: state,
|
||||
preset: cleanPreset,
|
||||
});
|
||||
}
|
||||
}
|
||||
return [...units.values()].sort((a, b) => a.name.localeCompare(b.name));
|
||||
}
|
||||
|
||||
export const DETAIL_PROPS = [
|
||||
"Id",
|
||||
"Description",
|
||||
"LoadState",
|
||||
"ActiveState",
|
||||
"SubState",
|
||||
"UnitFileState",
|
||||
"UnitFilePreset",
|
||||
"Result",
|
||||
"MainPID",
|
||||
"ExecMainStartTimestamp",
|
||||
"ActiveEnterTimestamp",
|
||||
"InactiveEnterTimestamp",
|
||||
"MemoryCurrent",
|
||||
"MemoryPeak",
|
||||
"CPUUsageNSec",
|
||||
"TasksCurrent",
|
||||
"NRestarts",
|
||||
"FragmentPath",
|
||||
"DropInPaths",
|
||||
"Requires",
|
||||
"Wants",
|
||||
"After",
|
||||
"WantedBy",
|
||||
"TriggeredBy",
|
||||
"Triggers",
|
||||
"User",
|
||||
"Group",
|
||||
"Restart",
|
||||
"Type",
|
||||
"ExecStart",
|
||||
"CanStart",
|
||||
"CanStop",
|
||||
"CanReload",
|
||||
] as const;
|
||||
|
||||
export function detailScript(unit: string): string {
|
||||
const props = DETAIL_PROPS.map((p) => `-p ${p}`).join(" ");
|
||||
return `
|
||||
systemctl show --no-pager ${props} -- ${q(requireUnit(unit))}
|
||||
echo "@@TERMIX_STATUS@@"
|
||||
systemctl status --no-pager --full -n 0 -- ${q(unit)} 2>&1
|
||||
exit 0
|
||||
`;
|
||||
}
|
||||
|
||||
export function parseDetail(unit: string, output: string): UnitDetail {
|
||||
const [props = "", status = ""] = output.split("@@TERMIX_STATUS@@");
|
||||
return { name: unit, props: parseKeys(props), status: status.trim() };
|
||||
}
|
||||
|
||||
const VERBS: Record<UnitAction, string> = {
|
||||
start: "start",
|
||||
stop: "stop",
|
||||
restart: "restart",
|
||||
reload: "reload",
|
||||
enable: "enable",
|
||||
disable: "disable",
|
||||
"enable-now": "enable --now",
|
||||
"disable-now": "disable --now",
|
||||
mask: "mask",
|
||||
unmask: "unmask",
|
||||
"reset-failed": "reset-failed",
|
||||
revert: "revert",
|
||||
};
|
||||
|
||||
/** The systemctl call for an action. Prints `state=` after it. */
|
||||
export function actionScript(unit: string, action: UnitAction): string {
|
||||
const verb = VERBS[action];
|
||||
if (!verb) throw new HostScriptError("Unknown action");
|
||||
const u = q(requireUnit(unit));
|
||||
return `
|
||||
systemctl ${verb} -- ${u} 2>&1 || { echo "SCRIPT_ERR:systemctl ${verb} failed"; exit 1; }
|
||||
echo "state=$(systemctl is-active -- ${u} 2>/dev/null)"
|
||||
`;
|
||||
}
|
||||
|
||||
/** Times systemctl prints under TZ=UTC, like "Thu 2026-10-22 02:03:51 UTC". */
|
||||
export function parseSystemdTime(value: string | undefined): number | null {
|
||||
if (!value) return null;
|
||||
const match = /(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/.exec(value);
|
||||
if (!match) return null;
|
||||
const [, y, mo, d, h, mi, s] = match.map(Number);
|
||||
return Date.UTC(y, mo - 1, d, h, mi, s);
|
||||
}
|
||||
|
||||
export const TIMERS_SCRIPT = `
|
||||
UNITS=$( { systemctl list-units --all --type=timer --plain --no-legend --no-pager --full 2>/dev/null | awk '{print $1}'; systemctl list-unit-files --type=timer --plain --no-legend --no-pager --full 2>/dev/null | awk '{print $1}'; } | grep '\\.timer$' | grep -v '@\\.timer$' | sort -u)
|
||||
[ -n "$UNITS" ] || exit 0
|
||||
systemctl show --no-pager -p Id -p Description -p ActiveState -p UnitFileState -p NextElapseUSecRealtime -p LastTriggerUSec -p Triggers -p TimersCalendar -p TimersMonotonic -- $UNITS
|
||||
exit 0
|
||||
`;
|
||||
|
||||
/** Reads systemctl show output for many units, split by blank lines. */
|
||||
export function parseShowBlocks(output: string): Array<Record<string, string>> {
|
||||
const blocks: Array<Record<string, string>> = [];
|
||||
for (const block of output.split(/\n\s*\n/)) {
|
||||
const lines = block.split("\n").filter((line) => line.includes("="));
|
||||
if (!lines.length) continue;
|
||||
// A unit can have several TimersCalendar lines; keep all of them.
|
||||
const keys: Record<string, string> = {};
|
||||
for (const line of lines) {
|
||||
const eq = line.indexOf("=");
|
||||
const key = line.slice(0, eq).trim();
|
||||
const value = line.slice(eq + 1).trim();
|
||||
keys[key] = key in keys ? `${keys[key]}\n${value}` : value;
|
||||
}
|
||||
blocks.push(keys);
|
||||
}
|
||||
return blocks;
|
||||
}
|
||||
|
||||
function schedules(value: string | undefined): string[] {
|
||||
if (!value) return [];
|
||||
const out: string[] = [];
|
||||
for (const line of value.split("\n")) {
|
||||
const match = /\{\s*(\w+)=(.+?)\s*;/.exec(line);
|
||||
if (match) out.push(`${match[1]}=${match[2]}`);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
export function parseTimers(output: string): TimerView[] {
|
||||
return parseShowBlocks(output)
|
||||
.filter((keys) => keys.Id?.endsWith(".timer"))
|
||||
.map((keys) => ({
|
||||
name: keys.Id,
|
||||
description: keys.Description ?? "",
|
||||
active: keys.ActiveState ?? "",
|
||||
fileState: keys.UnitFileState ?? "",
|
||||
next: parseSystemdTime(keys.NextElapseUSecRealtime),
|
||||
last: parseSystemdTime(keys.LastTriggerUSec),
|
||||
activates: (keys.Triggers ?? "").split(/\s+/)[0] ?? "",
|
||||
schedule: [
|
||||
...schedules(keys.TimersCalendar),
|
||||
...schedules(keys.TimersMonotonic),
|
||||
],
|
||||
}))
|
||||
.sort((a, b) => (a.next ?? Infinity) - (b.next ?? Infinity));
|
||||
}
|
||||
|
||||
/** One line per unit from systemctl is-active, in the order asked. */
|
||||
export function isActiveScript(units: string[]): string {
|
||||
return `systemctl is-active -- ${units.map((u) => q(requireUnit(u))).join(" ")} 2>/dev/null; exit 0\n`;
|
||||
}
|
||||
|
||||
export function parseIsActive(
|
||||
units: string[],
|
||||
output: string,
|
||||
): Map<string, string> {
|
||||
const lines = output.split("\n").map((line) => line.trim());
|
||||
const out = new Map<string, string>();
|
||||
units.forEach((unit, i) => out.set(unit, lines[i] || "unknown"));
|
||||
return out;
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
/**
|
||||
* Quoting, encoding and the error type the host scripts share.
|
||||
*
|
||||
* No Node APIs here: this entry also runs in the mobile app.
|
||||
*/
|
||||
|
||||
/** A bad input to a host script builder. `status` is the HTTP status to answer with. */
|
||||
export class HostScriptError extends Error {
|
||||
constructor(
|
||||
message: string,
|
||||
readonly status = 400,
|
||||
readonly extra: Record<string, unknown> = {},
|
||||
) {
|
||||
super(message);
|
||||
this.name = "HostScriptError";
|
||||
}
|
||||
}
|
||||
|
||||
/** Wraps a value in single quotes for a POSIX shell. */
|
||||
export function shellQuote(value: string): string {
|
||||
return `'${value.replace(/'/g, `'\\''`)}'`;
|
||||
}
|
||||
|
||||
// Written by hand because some JS engines (Hermes) have no TextDecoder.
|
||||
|
||||
/** UTF-8 bytes of a string. */
|
||||
export function utf8Encode(text: string): Uint8Array {
|
||||
const out: number[] = [];
|
||||
for (const char of text) {
|
||||
const cp = char.codePointAt(0) ?? 0xfffd;
|
||||
if (cp < 0x80) out.push(cp);
|
||||
else if (cp < 0x800) out.push(0xc0 | (cp >> 6), 0x80 | (cp & 63));
|
||||
else if (cp < 0x10000) {
|
||||
out.push(0xe0 | (cp >> 12), 0x80 | ((cp >> 6) & 63), 0x80 | (cp & 63));
|
||||
} else {
|
||||
out.push(
|
||||
0xf0 | (cp >> 18),
|
||||
0x80 | ((cp >> 12) & 63),
|
||||
0x80 | ((cp >> 6) & 63),
|
||||
0x80 | (cp & 63),
|
||||
);
|
||||
}
|
||||
}
|
||||
return Uint8Array.from(out);
|
||||
}
|
||||
|
||||
/** A string from UTF-8 bytes. Bad sequences become U+FFFD. */
|
||||
export function utf8Decode(bytes: ArrayLike<number>): string {
|
||||
let out = "";
|
||||
let i = 0;
|
||||
while (i < bytes.length) {
|
||||
const b = bytes[i];
|
||||
let need = 0;
|
||||
let cp = 0;
|
||||
if (b < 0x80) cp = b;
|
||||
else if (b >= 0xc2 && b < 0xe0) [need, cp] = [1, b & 31];
|
||||
else if (b >= 0xe0 && b < 0xf0) [need, cp] = [2, b & 15];
|
||||
else if (b >= 0xf0 && b < 0xf5) [need, cp] = [3, b & 7];
|
||||
else {
|
||||
out += "\ufffd";
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
let j = 1;
|
||||
for (; j <= need; j++) {
|
||||
const next = bytes[i + j];
|
||||
if (next === undefined || (next & 0xc0) !== 0x80) break;
|
||||
cp = (cp << 6) | (next & 63);
|
||||
}
|
||||
const tooSmall = [0, 0x80, 0x800, 0x10000][need];
|
||||
if (
|
||||
j <= need ||
|
||||
cp < tooSmall ||
|
||||
cp > 0x10ffff ||
|
||||
(cp >= 0xd800 && cp < 0xe000)
|
||||
) {
|
||||
out += "\ufffd";
|
||||
i += Math.max(1, j);
|
||||
continue;
|
||||
}
|
||||
out += String.fromCodePoint(cp);
|
||||
i += need + 1;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
const B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
|
||||
/** Base64 of the UTF-8 bytes of a string, for `base64 -d` on the host. */
|
||||
export function toBase64(text: string): string {
|
||||
const bytes = utf8Encode(text);
|
||||
let out = "";
|
||||
for (let i = 0; i < bytes.length; i += 3) {
|
||||
const a = bytes[i];
|
||||
const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
|
||||
const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
|
||||
const n = (a << 16) | (b << 8) | c;
|
||||
out += B64[(n >> 18) & 63] + B64[(n >> 12) & 63];
|
||||
out += i + 1 < bytes.length ? B64[(n >> 6) & 63] : "=";
|
||||
out += i + 2 < bytes.length ? B64[n & 63] : "=";
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** Reads key=value lines. Only the first = splits a line. */
|
||||
export function parseKeys(output: string): Record<string, string> {
|
||||
const out: Record<string, string> = {};
|
||||
for (const line of output.split("\n")) {
|
||||
const eq = line.indexOf("=");
|
||||
if (eq > 0) out[line.slice(0, eq).trim()] = line.slice(eq + 1).trim();
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** Trims output and keeps it short enough to show. */
|
||||
export function scrub(text: string, max = 600): string {
|
||||
return text.trim().slice(0, max);
|
||||
}
|
||||
@@ -37,7 +37,7 @@ export {
|
||||
* "^1.2" needs 1.2 or later). engine.termix is checked against the core
|
||||
* version by the server.
|
||||
*/
|
||||
export const PLUGIN_API_VERSION = "1.12.0";
|
||||
export const PLUGIN_API_VERSION = "1.13.0";
|
||||
|
||||
/** The API major, the default engine.api for a new plugin. */
|
||||
export const SUPPORTED_PLUGIN_API_VERSION = String(
|
||||
@@ -526,6 +526,36 @@ export interface PluginContributions {
|
||||
layouts?: PluginLayoutContribution[];
|
||||
/** Themes. Needs the ui:theme capability. */
|
||||
themes?: PluginThemeContribution[];
|
||||
/** How the plugin shows in the Termix mobile app. Plugin API 1.13. */
|
||||
mobile?: PluginMobileContribution;
|
||||
}
|
||||
|
||||
/**
|
||||
* - "webview": the app shows the plugin's UI from the server in a WebView.
|
||||
* - "native": the app has its own screens for this plugin.
|
||||
* - "none": nothing to show in the app.
|
||||
*/
|
||||
export const MOBILE_MODES = ["webview", "native", "none"] as const;
|
||||
export type PluginMobileMode = (typeof MOBILE_MODES)[number];
|
||||
|
||||
export const MOBILE_SIZES = ["phone", "tablet"] as const;
|
||||
export type PluginMobileSize = (typeof MOBILE_SIZES)[number];
|
||||
|
||||
export interface PluginMobileContribution {
|
||||
mode: PluginMobileMode;
|
||||
/**
|
||||
* webview: a bundle built for the app, in the same folder as the frontend
|
||||
* bundle. Unset means the normal frontend runs in a phone sized frame.
|
||||
*/
|
||||
entry?: string;
|
||||
/** webview: screen sizes the UI works at. Defaults to both. */
|
||||
sizes?: PluginMobileSize[];
|
||||
/** webview: tab, panel or card ids the app offers. Defaults to every tab. */
|
||||
views?: string[];
|
||||
/** native: the app feature that stands in for it. Defaults to the plugin id. */
|
||||
feature?: string;
|
||||
/** i18n key in the plugin's namespace, or plain text, shown in the app. */
|
||||
note?: string;
|
||||
}
|
||||
|
||||
/** A field a protocol login carries besides username and password. */
|
||||
@@ -765,6 +795,7 @@ const ALLOWED_CONTRIBUTES = new Set([
|
||||
"protocols",
|
||||
"layouts",
|
||||
"themes",
|
||||
"mobile",
|
||||
]);
|
||||
|
||||
const ALLOWED_SETTINGS_FIELD = [
|
||||
@@ -946,10 +977,135 @@ export function validateManifest(manifest: unknown): string[] {
|
||||
typeof m.id === "string" ? m.id : undefined,
|
||||
errors,
|
||||
);
|
||||
if (isPlainObject(m.contributes)) {
|
||||
validateMobile(
|
||||
m.contributes,
|
||||
typeof m.frontend === "string" ? m.frontend : DEFAULT_FRONTEND_ENTRY,
|
||||
errors,
|
||||
);
|
||||
}
|
||||
|
||||
return errors;
|
||||
}
|
||||
|
||||
function folderOf(file: string): string {
|
||||
const parts = file.split("/").filter((part) => part !== "" && part !== ".");
|
||||
return parts.slice(0, -1).join("/");
|
||||
}
|
||||
|
||||
function validateMobile(
|
||||
contributes: Record<string, unknown>,
|
||||
frontend: string,
|
||||
errors: string[],
|
||||
): void {
|
||||
const mobile = contributes.mobile;
|
||||
if (mobile === undefined) return;
|
||||
const where = "contributes.mobile";
|
||||
if (!isPlainObject(mobile)) {
|
||||
errors.push(`Field "${where}" must be an object`);
|
||||
return;
|
||||
}
|
||||
rejectUnknown(
|
||||
mobile,
|
||||
["mode", "entry", "sizes", "views", "feature", "note"],
|
||||
`"${where}"`,
|
||||
errors,
|
||||
);
|
||||
const mode = mobile.mode;
|
||||
if (!(MOBILE_MODES as readonly unknown[]).includes(mode)) {
|
||||
errors.push(`${where}.mode must be one of: ${MOBILE_MODES.join(", ")}`);
|
||||
return;
|
||||
}
|
||||
for (const key of ["entry", "sizes", "views"]) {
|
||||
if (mobile[key] !== undefined && mode !== "webview") {
|
||||
errors.push(`${where}.${key} is only for mode "webview"`);
|
||||
}
|
||||
}
|
||||
if (mobile.feature !== undefined && mode !== "native") {
|
||||
errors.push(`${where}.feature is only for mode "native"`);
|
||||
}
|
||||
|
||||
if (
|
||||
mobile.entry !== undefined &&
|
||||
requireString(mobile.entry, `${where}.entry`, errors)
|
||||
) {
|
||||
const before = errors.length;
|
||||
requireRelativePath(mobile.entry, `${where}.entry`, errors);
|
||||
if (!mobile.entry.endsWith(".js")) {
|
||||
errors.push(`${where}.entry must be a .js file`);
|
||||
} else if (
|
||||
errors.length === before &&
|
||||
folderOf(mobile.entry) !== folderOf(frontend)
|
||||
) {
|
||||
// Core only serves the folder the frontend bundle sits in.
|
||||
errors.push(
|
||||
`${where}.entry must sit in the same folder as the frontend bundle (${frontend})`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
if (mobile.sizes !== undefined) {
|
||||
const sizes = mobile.sizes;
|
||||
if (!Array.isArray(sizes) || sizes.length === 0) {
|
||||
errors.push(`${where}.sizes must be a non-empty array`);
|
||||
} else {
|
||||
const seen = new Set<unknown>();
|
||||
for (const size of sizes) {
|
||||
if (!(MOBILE_SIZES as readonly unknown[]).includes(size)) {
|
||||
errors.push(
|
||||
`${where}.sizes entries must be one of: ${MOBILE_SIZES.join(", ")}`,
|
||||
);
|
||||
} else if (seen.has(size)) {
|
||||
errors.push(`${where}.sizes duplicates "${String(size)}"`);
|
||||
}
|
||||
seen.add(size);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (mobile.views !== undefined) {
|
||||
const views = mobile.views;
|
||||
if (!Array.isArray(views) || views.length === 0) {
|
||||
errors.push(`${where}.views must be a non-empty array`);
|
||||
} else {
|
||||
const declared = new Set<string>();
|
||||
for (const field of ["tabs", "panels", "dashboardCards"]) {
|
||||
const list = contributes[field];
|
||||
if (!Array.isArray(list)) continue;
|
||||
for (const view of list) {
|
||||
if (isPlainObject(view) && typeof view.id === "string") {
|
||||
declared.add(view.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
const seen = new Set<unknown>();
|
||||
for (const view of views) {
|
||||
if (typeof view !== "string" || !declared.has(view)) {
|
||||
errors.push(
|
||||
`${where}.views entries must be ids from contributes.tabs, panels or dashboardCards, got: ${JSON.stringify(view)}`,
|
||||
);
|
||||
} else if (seen.has(view)) {
|
||||
errors.push(`${where}.views duplicates "${view}"`);
|
||||
}
|
||||
seen.add(view);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
mobile.feature !== undefined &&
|
||||
(typeof mobile.feature !== "string" ||
|
||||
!LOOK_ID_PATTERN.test(mobile.feature))
|
||||
) {
|
||||
errors.push(
|
||||
`${where}.feature must match ${LOOK_ID_PATTERN} (lowercase letters, digits, dashes)`,
|
||||
);
|
||||
}
|
||||
if (mobile.note !== undefined) {
|
||||
requireString(mobile.note, `${where}.note`, errors);
|
||||
}
|
||||
}
|
||||
|
||||
function validateFeatures(features: unknown, errors: string[]): void {
|
||||
if (features === undefined) return;
|
||||
if (!Array.isArray(features)) {
|
||||
|
||||
@@ -403,6 +403,7 @@ getDeviceId (value): () => string
|
||||
getErrorMessage (value): (error: unknown, fallback?: string) => string
|
||||
getExternalAutoProvision (value): () => Promise<{ enabled: boolean; }>
|
||||
getFolderAccess (value): (folder: string) => Promise<{ rules: FolderAccessRule[]; }>
|
||||
getFolderAuthOverride (value): (folder: string, protocol: string, sharedCopySyncId?: string) => Promise<{ folder: string; protocol: string; credentialId: number; }>
|
||||
getFolderDefaultsId (value): (name: string) => Promise<number>
|
||||
getHostAccess (value): (hostId: number, syncId?: string) => Promise<{ accessList: AccessRecord[]; isOwner?: boolean; }>
|
||||
getHostAuthOverride (value): (hostId: number, protocol: string, sharedCopySyncId?: string) => Promise<{ protocol: string; credentialId: number; }>
|
||||
@@ -526,7 +527,7 @@ resolveHostTabType (value): (host: Host, preferredType?: TabType) => TabType
|
||||
resolveRemoteHostId (value): (syncId: string) => Promise<number>
|
||||
revokeAllUserSessions (value): (userId: string) => Promise<{ success: boolean; message: string; }>
|
||||
revokeCredentialAccess (value): (credentialId: number, accessId: number) => Promise<void>
|
||||
revokeFolderAccess (value): (ruleId: number) => Promise<void>
|
||||
revokeFolderAccess (value): (ruleId: number, options?: { fromHosts?: boolean; }) => Promise<void>
|
||||
revokeHostAccess (value): (hostId: number, accessId: number, syncId?: string) => Promise<{ success: boolean; }>
|
||||
revokeSession (value): (sessionId: string) => Promise<{ success: boolean; message: string; }>
|
||||
rightDockableIds (value): () => string[]
|
||||
@@ -544,6 +545,7 @@ saveHostTags (value): (tags: string[]) => Promise<string[]>
|
||||
saveUserPreferences (value): (prefs: Partial<UserPreferences>) => Promise<void>
|
||||
setAllPluginChannels (value): (channel: PluginChannel) => Promise<{ changed: string[]; }>
|
||||
setDeveloperMode (value): (enabled: boolean) => Promise<void>
|
||||
setFolderAuthOverride (value): (folder: string, protocol: string, credentialId: number, sharedCopySyncId?: string) => Promise<{ success: boolean; folder: string; protocol: string; credentialId: number; }>
|
||||
setHostAuthOverride (value): (hostId: number, protocol: string, credentialId: number, sharedCopySyncId?: string) => Promise<{ success: boolean; protocol: string; credentialId: number; }>
|
||||
setNotificationPrivateEndpoints (value): (hosts: string[]) => Promise<string[]>
|
||||
setPluginOptions (value): (pluginId: string, options: { autoUpdate?: boolean; pinned?: boolean; channel?: PluginChannel; }) => Promise<{ autoUpdate: boolean; pinnedVersion: string; channel: PluginChannel; }>
|
||||
|
||||
Reference in new issue
Block a user