@deveye/types 0.15.2 → 0.16.0

package/src/features/deploy.ts

@@ -1,245 +0,0 @@
-import { z } from 'zod';
-import {
-    CREDENTIAL_LABEL_MAX_LENGTH,
-    CREDENTIAL_SECRET_MAX_LENGTH,
-    credentialSchema
-} from '../domain/credential';
-import {
-    DEPLOY_DESCRIPTION_MAX_LENGTH,
-    DEPLOY_EXTERNAL_ID_MAX_LENGTH,
-    DEPLOY_TARGET_NAME_MAX_LENGTH,
-    DEPLOY_TITLE_MAX_LENGTH,
-    deployCandidateSchema,
-    deployHistoryEntrySchema,
-    deployTargetKindSchema,
-    deployTargetSchema,
-    deploymentSchema
-} from '../domain/deploy';
-
-/**
- * Commandes du déploiement.
- *
- * Feature d'espace de premier rang, sur le modèle de Git : une cible appartient
- * à l'espace, un projet n'y **pointe** (voir `project.deployLink`). Tout est à
- * l'étage ouvert, donc aucune de ces commandes ne demande de session
- * déverrouillée.
- *
- * Les clés d'API Dokploy vivent ici et non plus dans la feature Git, où elles
- * n'avaient atterri que faute de module pour les accueillir : poser la clé qui
- * déploie relève de `deploy`, pas de `git`.
- */
-
-const targetId = z.number().int().positive();
-const credentialId = z.number().int().positive();
-
-/** Les cibles de l'espace, dans l'ordre choisi par l'utilisateur. */
-export const deployList = {
-    command: 'deploy.list' as const,
-    input: z.object({}),
-    output: z.object({ targets: z.array(deployTargetSchema) })
-};
-
-/**
- * Compte les cibles. Métadonnée en clair pure : la tuile d'accueil affiche
- * toujours un nombre, même session verrouillée.
- */
-export const deployCount = {
-    command: 'deploy.count' as const,
-    input: z.object({}),
-    output: z.object({ count: z.number().int().nonnegative() })
-};
-
-/** Une cible et son historique de déclenchements, du plus récent au plus ancien. */
-export const deployGet = {
-    command: 'deploy.get' as const,
-    input: z.object({ targetId, limit: z.number().int().positive().max(50).optional() }),
-    output: z.object({
-        target: deployTargetSchema,
-        deployments: z.array(deploymentSchema),
-        /** Les projets qui la déploient, pour que la fiche sache où elle sert. */
-        projectIds: z.array(z.number().int().positive())
-    })
-};
-
-/**
- * Déclare une cible. **Idempotente** sur (jeton, identifiant externe) : la même
- * application déclarée deux fois est la même cible, et la seconde déclaration
- * met simplement son intitulé à jour.
- */
-export const deployAdd = {
-    command: 'deploy.add' as const,
-    input: z.object({
-        credentialId,
-        kind: deployTargetKindSchema,
-        externalId: z.string().min(1).max(DEPLOY_EXTERNAL_ID_MAX_LENGTH),
-        name: z.string().min(1).max(DEPLOY_TARGET_NAME_MAX_LENGTH)
-    }),
-    output: z.object({ target: deployTargetSchema })
-};
-
-/** Change le jeton, le type ou l'intitulé d'une cible. */
-export const deployUpdate = {
-    command: 'deploy.update' as const,
-    input: z.object({
-        targetId,
-        credentialId: credentialId.nullable(),
-        kind: deployTargetKindSchema,
-        externalId: z.string().min(1).max(DEPLOY_EXTERNAL_ID_MAX_LENGTH),
-        name: z.string().min(1).max(DEPLOY_TARGET_NAME_MAX_LENGTH)
-    }),
-    output: z.object({ target: deployTargetSchema })
-};
-
-/**
- * Supprime une cible, **et son historique avec elle**.
- *
- * L'application chez le fournisseur n'est pas touchée : DevEye ne fait que la
- * pointer. Les projets qui la déployaient perdent leur liaison, rien d'autre.
- */
-export const deployRemove = {
-    command: 'deploy.remove' as const,
-    input: z.object({ targetId }),
-    output: z.object({ targetId })
-};
-
-/** Range la liste : `targetIds` en est le contenu complet, dans son ordre final. */
-export const deployReorder = {
-    command: 'deploy.reorder' as const,
-    input: z.object({ targetIds: z.array(targetId).min(1) }),
-    output: z.object({ targetIds: z.array(targetId) })
-};
-
-/**
- * Les applications proposées par l'instance, pour en choisir une.
- *
- * Seule commande du module qui appelle un service externe en direct : elle sert
- * à remplir un sélecteur, et attendre le prochain tour d'un ordonnanceur pour
- * voir apparaître la liste n'aurait aucun sens.
- */
-export const deployCandidates = {
-    command: 'deploy.candidates' as const,
-    input: z.object({ credentialId }),
-    output: z.object({ candidates: z.array(deployCandidateSchema) })
-};
-
-/**
- * Déclenche un déploiement.
- *
- * Toujours audité en `warn` : c'est la seule action du module qui produise un
- * effet **hors** de DevEye, et savoir qui a poussé quoi en production compte
- * plus que le reste.
- *
- * `projectId` est facultatif et ne sert qu'à la frise du projet : déclenché
- * depuis l'onglet d'un projet, l'événement y est inscrit ; déclenché depuis la
- * feature, il n'appartient à aucun projet en particulier.
- */
-export const deployTrigger = {
-    command: 'deploy.trigger' as const,
-    input: z.object({
-        targetId,
-        title: z.string().max(DEPLOY_TITLE_MAX_LENGTH),
-        description: z.string().max(DEPLOY_DESCRIPTION_MAX_LENGTH),
-        projectId: z.number().int().positive().optional()
-    }),
-    output: z.object({ deployment: deploymentSchema })
-};
-
-/**
- * L'historique complet d'une cible, **tel que Dokploy le rend** — pas
- * seulement ce que DevEye a déclenché : un déploiement lancé depuis
- * l'interface de Dokploy ou une CI y apparaît aussi.
- *
- * Distincte de `deployGet`, qui reste le suivi local (léger, toujours
- * disponible sans réseau vers le fournisseur) : celle-ci interroge Dokploy en
- * direct à chaque appel, coûte une requête externe, et n'a donc de sens que
- * là où on la demande explicitement — la fiche d'une cible dans la feature,
- * pas l'onglet d'un projet qui en reliste plusieurs.
- */
-export const deployHistory = {
-    command: 'deploy.history' as const,
-    input: z.object({ targetId }),
-    output: z.object({ entries: z.array(deployHistoryEntrySchema) })
-};
-
-/**
- * Le journal complet d'un déploiement, tel que Dokploy l'a produit.
- *
- * `externalId` vient d'une ligne de `deployHistory` : c'est la seule façon dont
- * le client connaît un déploiement dont DevEye n'a pas forcément la ligne
- * locale. Repose sur un point d'entrée de Dokploy sans procédure tRPC dédiée
- * (voir l'adaptateur `dokploy.ts`) : peut échouer sur une instance qui
- * l'authentifie autrement, ou pas du tout — l'appelant le traite alors comme
- * n'importe quelle autre panne réseau.
- */
-export const deployLog = {
-    command: 'deploy.log' as const,
-    input: z.object({ targetId, externalId: z.string().min(1) }),
-    output: z.object({ log: z.string() })
-};
-
-// ------------------------------------------------------------------ jetons
-
-/**
- * Les clés d'API Dokploy de l'espace.
- *
- * Quatre commandes jumelles de `git.credential*` : même table, même forme, mais
- * chaque feature n'expose que les jetons de ses fournisseurs et les garde
- * derrière son propre droit. Le secret n'est jamais rendu.
- */
-export const deployCredentialList = {
-    command: 'deploy.credentialList' as const,
-    input: z.object({}),
-    output: z.object({ credentials: z.array(credentialSchema) })
-};
-
-/** Une instance Dokploy exige son adresse : sans elle, rien n'est adressable. */
-export const deployCredentialAdd = {
-    command: 'deploy.credentialAdd' as const,
-    input: z.object({
-        label: z.string().min(1).max(CREDENTIAL_LABEL_MAX_LENGTH),
-        baseUrl: z.string().min(1).max(255),
-        secret: z.string().min(1).max(CREDENTIAL_SECRET_MAX_LENGTH)
-    }),
-    output: z.object({ credential: credentialSchema })
-};
-
-/** `secret` omis = inchangé : le serveur ne l'a jamais rendu, on ne le réécrit pas. */
-export const deployCredentialUpdate = {
-    command: 'deploy.credentialUpdate' as const,
-    input: z.object({
-        credentialId,
-        label: z.string().min(1).max(CREDENTIAL_LABEL_MAX_LENGTH),
-        baseUrl: z.string().min(1).max(255),
-        secret: z.string().min(1).max(CREDENTIAL_SECRET_MAX_LENGTH).optional()
-    }),
-    output: z.object({ credential: credentialSchema })
-};
-
-/**
- * Retire un jeton. Les cibles qui s'en servaient **restent**, sans jeton
- * (`ON DELETE SET NULL`) : elles cessent d'être déployables et le disent, plutôt
- * que de disparaître avec leur clé.
- */
-export const deployCredentialRemove = {
-    command: 'deploy.credentialRemove' as const,
-    input: z.object({ credentialId }),
-    output: z.object({ credentialId })
-};
-
-export const deployCommands = [
-    deployList,
-    deployCount,
-    deployGet,
-    deployAdd,
-    deployUpdate,
-    deployRemove,
-    deployReorder,
-    deployCandidates,
-    deployTrigger,
-    deployHistory,
-    deployLog,
-    deployCredentialList,
-    deployCredentialAdd,
-    deployCredentialUpdate,
-    deployCredentialRemove
-] as const;

package/src/features/device.ts

@@ -1,292 +0,0 @@
-import { z } from 'zod';
-import { deviceSchema } from '../domain/device';
-import { packageManagerIdSchema } from '../domain/packages';
-import { agentLifecycleActionSchema, agentPowerActionSchema } from '../protocol/agent';
-import { processCaptureSchema } from '../domain/report';
-import { workspaceKindSchema } from '../domain/workspace';
-
-const deviceId = z.uuid();
-
-/** List devices visible to the caller (own devices; all devices for admins). */
-export const deviceList = {
-    command: 'device.list' as const,
-    input: z.object({
-        /**
-         * `workspace` (défaut) : les appareils de l'espace actif — ce qu'affichent
-         * l'accueil, la topbar et Monitoring.
-         * `fleet` : toute la flotte, tous espaces confondus. Réservé aux
-         * administrateurs, pour la page Appareils.
-         */
-        scope: z.enum(['workspace', 'fleet']).optional()
-    }),
-    output: z.object({ devices: z.array(deviceSchema) })
-};
-
-/** Confirm a `pending` device, moving it to `active`. */
-export const deviceConfirm = {
-    command: 'device.confirm' as const,
-    input: z.object({ deviceId }),
-    output: z.object({ device: deviceSchema })
-};
-
-/** Revoke a device: its token is rejected and it can no longer push metrics. */
-export const deviceRevoke = {
-    command: 'device.revoke' as const,
-    input: z.object({ deviceId }),
-    output: z.object({ device: deviceSchema })
-};
-
-/**
- * Lay out the workspace's devices: `ids` is the **complete** list in its final
- * order (lower index first). New devices are appended, so the order is entirely
- * the user's — as it is for monitored services, repositories and notes.
- *
- * Scoped to the active workspace, and gated on `devices: write` rather than on
- * `admin: true` like the rest of this module: arranging a list one's own
- * workspace displays is not fleet management. Touches no agent state.
- */
-export const deviceReorder = {
-    command: 'device.reorder' as const,
-    input: z.object({ ids: z.array(deviceId).min(1) }),
-    output: z.object({ ids: z.array(deviceId) })
-};
-
-export const deviceRename = {
-    command: 'device.rename' as const,
-    input: z.object({ deviceId, name: z.string().min(1).max(128) }),
-    output: z.object({ device: deviceSchema })
-};
-
-/**
- * Update a device's collection config. Every field is optional; only the
- * provided ones change. `null` resets a field to the server default. Interval
- * or capture changes are pushed live to a connected agent.
- */
-export const deviceSetConfig = {
-    command: 'device.setConfig' as const,
-    input: z
-        .object({
-            deviceId,
-            /** Collection interval in seconds — metrics *and* processes (5s–1h). */
-            metricIntervalSeconds: z.number().int().min(5).max(3600).nullable().optional(),
-            processCapture: processCaptureSchema.nullable().optional(),
-            /** Conservation de l'historique — métriques, présence et processus. */
-            retentionDays: z.number().int().positive().max(3650).nullable().optional()
-        })
-        .refine(
-            (v) =>
-                v.metricIntervalSeconds !== undefined ||
-                v.processCapture !== undefined ||
-                v.retentionDays !== undefined,
-            { message: 'No config field provided' }
-        ),
-    output: z.object({ device: deviceSchema })
-};
-
-/** Un espace candidat au partage d'un appareil, tel que l'affiche la popup. */
-export const deviceShareTargetSchema = z.object({
-    id: z.number().int().positive(),
-    name: z.string(),
-    kind: workspaceKindSchema,
-    /** L'espace a-t-il accès à cet appareil ? */
-    shared: z.boolean()
-});
-export type DeviceShareTarget = z.infer<typeof deviceShareTargetSchema>;
-
-/**
- * Les espaces avec lesquels un appareil peut être partagé, et lesquels le sont.
- *
- * Réservé aux administrateurs : c'est la seule commande qui énumère des espaces
- * dont l'appelant n'est pas membre, et elle n'existe que pour la page Appareils.
- */
-export const deviceWorkspaceList = {
-    command: 'device.workspaceList' as const,
-    input: z.object({ deviceId }),
-    output: z.object({
-        /**
-         * Espace d'appairage : toujours partagé, jamais retirable. `null` si cet
-         * espace a été supprimé depuis — l'appareil n'a alors plus d'origine et
-         * tous ses partages sont révocables.
-         */
-        originWorkspaceId: z.number().int().positive().nullable(),
-        workspaces: z.array(deviceShareTargetSchema)
-    })
-};
-
-/**
- * Fixe l'ensemble des espaces ayant accès à un appareil. La liste est complète :
- * un espace absent perd l'accès. L'espace d'appairage est réintégré d'office.
- */
-export const deviceSetWorkspaces = {
-    command: 'device.setWorkspaces' as const,
-    input: z.object({
-        deviceId,
-        workspaceIds: z.array(z.number().int().positive())
-    }),
-    output: z.object({ device: deviceSchema })
-};
-
-/** Reactivate a revoked device, moving it back to `active`. */
-export const deviceReactivate = {
-    command: 'device.reactivate' as const,
-    input: z.object({ deviceId }),
-    output: z.object({ device: deviceSchema })
-};
-
-/**
- * Push a self-update to a connected device's agent: the server resolves the newer
- * signed binary for the device's build target and sends `agent.update`. Admin-only
- * (Appareils page). Fails if the agent is offline, has no known target, the binary
- * is missing/unsigned, or it's already up to date.
- */
-export const deviceUpdateAgent = {
-    command: 'device.updateAgent' as const,
-    input: z.object({ deviceId }),
-    output: z.object({ device: deviceSchema })
-};
-
-/**
- * Enable/disable the agent's per-user autostart (survives reboot, no privilege).
- * Pushes `agent.service` to the connected agent (`install-user`/`uninstall-user`).
- */
-export const deviceSetAutostart = {
-    command: 'device.setAutostart' as const,
-    input: z.object({ deviceId, enabled: z.boolean() }),
-    output: z.object({ device: deviceSchema })
-};
-
-/**
- * Ask the agent to become a root/system service. Hybrid: the agent pops an OS auth
- * prompt if it has an interactive session, else replies `needsManualCommand` and the
- * UI shows `manualCommand` (always returned, deterministic per platform) to run on
- * the device. The new privilege/scope is observed on the agent's next report.
- */
-export const deviceElevate = {
-    command: 'device.elevate' as const,
-    input: z.object({ deviceId }),
-    output: z.object({ device: deviceSchema, manualCommand: z.string() })
-};
-
-/** Ask a root/system agent to drop back to a per-user service. */
-export const deviceDropPrivileges = {
-    command: 'device.dropPrivileges' as const,
-    input: z.object({ deviceId }),
-    output: z.object({ device: deviceSchema, manualCommand: z.string() })
-};
-
-/**
- * Ask the agent to enumerate its package managers + pending updates. The result
- * arrives asynchronously as a `package.list` push event (the caller must be
- * subscribed to the device). The command itself only acknowledges the request.
- */
-export const deviceListPackages = {
-    command: 'device.listPackages' as const,
-    input: z.object({ deviceId }),
-    output: z.object({ ok: z.boolean() })
-};
-
-/**
- * Apply all pending updates of one manager. Progress streams as `package.progress`
- * events, ending with `package.done`. Fails if the agent is offline or the manager
- * needs root and the agent isn't privileged (elevate it first — see device.elevate).
- */
-export const deviceUpgradePackages = {
-    command: 'device.upgradePackages' as const,
-    input: z.object({ deviceId, manager: packageManagerIdSchema }),
-    output: z.object({ ok: z.boolean() })
-};
-
-/**
- * Run a system power action on the device (shutdown / reboot / suspend / hibernate
- * / lock). Owner-or-admin; the agent must be online. The command only acknowledges
- * the request — the agent applies it best-effort and the outcome streams back as a
- * `device.powerResult` push event (the caller must be subscribed to the device).
- */
-export const devicePower = {
-    command: 'device.power' as const,
-    input: z.object({ deviceId, action: agentPowerActionSchema }),
-    output: z.object({ ok: z.boolean() })
-};
-
-/**
- * Stop or cleanly restart the agent *process* on the device (not the machine).
- * - `stop`: the agent exits. With autostart (supervised service) the manager
- *   relaunches it within seconds; standalone, the device stays offline — and
- *   unmanageable remotely — until someone relaunches it on the machine.
- * - `restart`: exit-and-relaunch (manager or self-respawn), e.g. to pick up a
- *   clean state.
- * Owner-or-admin; the agent must be online. Fire-and-forget: the command only
- * acknowledges the push — the outcome is observed through presence.
- */
-export const deviceAgentLifecycle = {
-    command: 'device.agentLifecycle' as const,
-    input: z.object({ deviceId, action: agentLifecycleActionSchema }),
-    output: z.object({ ok: z.boolean() })
-};
-
-/**
- * Request a managed deletion (from the Appareils page). The device moves to
- * `pending_deletion`: on its next connection the agent is told to self-destruct
- * (wipe its local config + binary), after which the device is archived — its
- * monitoring history is kept and stays browsable, but it's gone from management.
- * If the agent is online the destroy signal is sent immediately.
- */
-export const deviceRequestDelete = {
-    command: 'device.requestDelete' as const,
-    input: z.object({ deviceId }),
-    output: z.object({ device: deviceSchema })
-};
-
-/** Cancel a `pending_deletion` (only effective while the agent hasn't reconnected). */
-export const deviceCancelDelete = {
-    command: 'device.cancelDelete' as const,
-    input: z.object({ deviceId }),
-    output: z.object({ device: deviceSchema })
-};
-
-/**
- * Finalise a deletion immediately: archive the device now without waiting for the
- * agent to self-destruct (use when the agent is gone, or you don't care if it
- * cleans itself up). A still-connected agent is told to self-destruct best-effort,
- * but the device is archived regardless; if it ever reconnects it's refused.
- */
-export const deviceForceDelete = {
-    command: 'device.forceDelete' as const,
-    input: z.object({ deviceId }),
-    output: z.object({ device: deviceSchema })
-};
-
-/**
- * Hard-purge a device and ALL its monitoring history (used by the Monitoring
- * page to remove an archived — or any — device and reset its data). Works
- * whether the agent is online or not; it does not self-destruct the agent.
- */
-export const deviceDelete = {
-    command: 'device.delete' as const,
-    input: z.object({ deviceId }),
-    output: z.object({ deviceId })
-};
-
-export const deviceCommands = [
-    deviceList,
-    deviceConfirm,
-    deviceRevoke,
-    deviceReactivate,
-    deviceRename,
-    deviceReorder,
-    deviceSetConfig,
-    deviceWorkspaceList,
-    deviceSetWorkspaces,
-    deviceUpdateAgent,
-    deviceSetAutostart,
-    deviceElevate,
-    deviceDropPrivileges,
-    deviceListPackages,
-    deviceUpgradePackages,
-    devicePower,
-    deviceAgentLifecycle,
-    deviceRequestDelete,
-    deviceCancelDelete,
-    deviceForceDelete,
-    deviceDelete
-] as const;

package/src/features/deviceFiles.ts

@@ -1,83 +0,0 @@
-import { z } from 'zod';
-import { fileMutateOpSchema, fileSearchFilterSchema } from '../domain/deviceFiles';
-
-const deviceId = z.uuid();
-/** Correlates a request to its streamed result (results carry no requestId). */
-const opId = z.string().min(1).max(64);
-const path = z.string().min(1).max(4096);
-
-/**
- * List a directory. Owner-or-admin + agent online. The listing arrives as a
- * `device.filesListing` push event keyed by `opId` (the caller must be subscribed).
- */
-export const deviceFilesList = {
-    command: 'device.filesList' as const,
-    input: z.object({ deviceId, opId, path }),
-    output: z.object({ ok: z.boolean() })
-};
-
-/**
- * Analyse a directory's recursive disk usage (ncdu-style): the total size of each
- * immediate child. Result arrives as a `device.filesUsage` push event.
- */
-export const deviceFilesAnalyze = {
-    command: 'device.filesAnalyze' as const,
-    input: z.object({ deviceId, opId, path }),
-    output: z.object({ ok: z.boolean() })
-};
-
-/**
- * Recursively search a directory with an advanced filter (name/extension/content,
- * date & size windows). Matches arrive as a `device.filesMatches` push event.
- */
-export const deviceFilesSearch = {
-    command: 'device.filesSearch' as const,
-    input: z.object({ deviceId, opId, path, filter: fileSearchFilterSchema }),
-    output: z.object({ ok: z.boolean() })
-};
-
-/**
- * Mutate the filesystem: `delete` (file or directory, recursive), `mkdir`, or
- * `rename` (needs `dest`). The outcome arrives as a `device.filesOp` push event.
- */
-export const deviceFilesMutate = {
-    command: 'device.filesMutate' as const,
-    input: z.object({ deviceId, opId, op: fileMutateOpSchema, path, dest: path.optional() }),
-    output: z.object({ ok: z.boolean() })
-};
-
-/**
- * Download a file. Bytes stream back as `device.filesChunk` push events keyed by
- * `opId` (base64, the last with `done: true`); the client reassembles them.
- */
-export const deviceFilesDownload = {
-    command: 'device.filesDownload' as const,
-    input: z.object({ deviceId, opId, path }),
-    output: z.object({ ok: z.boolean() })
-};
-
-/**
- * Upload one chunk of a file at `offset` (0 truncates/creates it). The completion
- * (on `done`) arrives as a `device.filesOp` push event (op `upload`).
- */
-export const deviceFilesUpload = {
-    command: 'device.filesUpload' as const,
-    input: z.object({
-        deviceId,
-        opId,
-        path,
-        offset: z.number().int().nonnegative(),
-        data: z.string().max(1_400_000),
-        done: z.boolean()
-    }),
-    output: z.object({ ok: z.boolean() })
-};
-
-export const deviceFilesCommands = [
-    deviceFilesList,
-    deviceFilesAnalyze,
-    deviceFilesSearch,
-    deviceFilesMutate,
-    deviceFilesDownload,
-    deviceFilesUpload
-] as const;

package/src/features/deviceLogs.ts

@@ -1,36 +0,0 @@
-import { z } from 'zod';
-import { deviceLogFilterSchema, DEVICE_LOG_PAGE_MAX } from '../domain/deviceLogs';
-
-const deviceId = z.uuid();
-
-/**
- * Ask the agent to enumerate the log sources present on the device (system journal,
- * Docker containers, log files…). Owner-or-admin + agent online. The command only
- * acknowledges; the list arrives as a `device.logSources` push event (the caller
- * must be subscribed to the device).
- */
-export const deviceLogSources = {
-    command: 'device.logSources' as const,
-    input: z.object({ deviceId }),
-    output: z.object({ ok: z.boolean() })
-};
-
-/**
- * Query one source with an advanced filter. `queryId` correlates the streamed
- * result back to this request (results have no requestId). Lines arrive as one or
- * more `device.logLines` push events, the last carrying `done: true`.
- */
-export const deviceLogQuery = {
-    command: 'device.logQuery' as const,
-    input: z.object({
-        deviceId,
-        sourceId: z.string().min(1).max(512),
-        /** Client-generated id echoed back on every `device.logLines` for this query. */
-        queryId: z.string().min(1).max(64),
-        filter: deviceLogFilterSchema.optional(),
-        limit: z.number().int().positive().max(DEVICE_LOG_PAGE_MAX).optional()
-    }),
-    output: z.object({ ok: z.boolean() })
-};
-
-export const deviceLogCommands = [deviceLogSources, deviceLogQuery] as const;