@petercjl/topazlabscli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peter Chen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+# topazlabscli
+
+`topazlabscli` is an npm-distributed CLI and portable Agent Skill for sending video-enhancement jobs to an authorized Windows workstation running Topaz Video AI. It uses the workstation's existing SSH service, Topaz installation, GPU, models, and license. Nothing in this package installs, redistributes, licenses, or unlocks Topaz software.
+
+## Requirements
+
+- Client: Node.js 20+, OpenSSH `ssh` and `sftp`.
+- Worker: Windows, OpenSSH Server, Topaz Video AI with its bundled FFmpeg/FFprobe, a logged-in licensed user, and downloaded model files.
+- Network access is configured separately. Each endpoint is ordinary user configuration; the package does not contain or manage VPN settings.
+
+## Install
+
+```powershell
+npm install --global @petercjl/topazlabscli
+topazlabscli skill install --agent all
+```
+
+## Configure a target
+
+Use one or more SSH endpoints in priority order. A LAN-only user configures only the LAN entry.
+
+```powershell
+topazlabscli target add gpu-workstation `
+  --endpoint lan=gpu-workstation `
+  --user Administrator `
+  --identity "$HOME\.ssh\gpu_workstation_ed25519" `
+  --workspace "E:\topazlab_workspace" `
+  --default
+```
+
+An authorized roaming user can add a second endpoint that resolves through their own VPN configuration:
+
+```powershell
+topazlabscli target add gpu-workstation `
+  --endpoint lan=gpu-workstation `
+  --endpoint vpn=gpu-workstation-vpn `
+  --user Administrator `
+  --identity "$HOME\.ssh\gpu_workstation_ed25519" `
+  --workspace "E:\topazlab_workspace" `
+  --default
+```
+
+The CLI tries endpoints in the order provided. It never starts or changes a VPN.
+
+## Set up and check the worker
+
+```powershell
+topazlabscli connection check --json
+topazlabscli worker install --json
+topazlabscli doctor --json
+topazlabscli model status --json
+```
+
+The worker uses a global Windows mutex and one queue consumer, so jobs from multiple clients run serially.
+
+## Process a video
+
+```powershell
+topazlabscli process .\input.mp4 --output .\output-1080p.mp4 --json
+```
+
+Asynchronous form:
+
+```powershell
+topazlabscli job submit .\input.mp4 --json
+topazlabscli job status JOB_ID --json
+topazlabscli job wait JOB_ID --json
+topazlabscli job download JOB_ID --output .\output-1080p.mp4 --json
+```
+
+Version 0.1 includes one preset: `seedance-human-1080p`, using Proteus v4 (`prob-4`), source FPS, aspect-preserving 1080p output, and NVIDIA H.264 encoding.
+
+## Configuration
+
+Configuration is stored outside the package:
+
+- Windows: `%APPDATA%\topazlabscli\config.json`
+- macOS/Linux: `${XDG_CONFIG_HOME:-~/.config}/topazlabscli/config.json`
+- Override for testing or automation: `TOPAZLABSCLI_CONFIG`
+
+Do not publish configuration files, keys, internal addresses, media, Topaz model files, or authentication data.

package/bin/topazlabscli.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { main } from "../src/cli.mjs";
+
+main(process.argv.slice(2)).catch((error) => {
+  const json = process.argv.includes("--json");
+  const payload = {
+    ok: false,
+    error: {
+      code: error.code || "UNEXPECTED_ERROR",
+      message: error.message || String(error),
+      details: error.details || null
+    }
+  };
+  if (json) process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+  else process.stderr.write(`[${payload.error.code}] ${payload.error.message}\n`);
+  process.exitCode = Number.isInteger(error.exitCode) ? error.exitCode : 1;
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@petercjl/topazlabscli",
+  "version": "0.1.0",
+  "description": "Cross-Agent CLI and portable Skill for queued remote Topaz Video AI processing",
+  "type": "module",
+  "bin": {
+    "topazlabscli": "bin/topazlabscli.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "worker",
+    "skill",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node --test",
+    "check": "node --check bin/topazlabscli.mjs && node --check src/cli.mjs && npm test"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/petercjl/topazlabscli.git"
+  },
+  "homepage": "https://github.com/petercjl/topazlabscli#readme",
+  "bugs": {
+    "url": "https://github.com/petercjl/topazlabscli/issues"
+  },
+  "license": "MIT",
+  "keywords": [
+    "topaz",
+    "video-ai",
+    "ssh",
+    "gpu",
+    "agent-skill"
+  ]
+}

package/skill/topazlabscli/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: topazlabscli
+description: Operate a configured remote Windows Topaz Video AI workstation through the stable topazlabscli CLI. Use for connection checks, Proteus model readiness, queued 480p-to-1080p enhancement jobs, status, download, cancellation, and installation diagnostics. Do not use for installing or licensing Topaz itself.
+---
+
+# TopazLabs CLI
+
+Use the CLI as the single execution surface. Do not reproduce SSH, SFTP, queue, or Topaz FFmpeg commands manually when the CLI supports the operation.
+
+## Input → Strategy → Output
+
+- Input: a local video path or a job identifier, the user's requested action, and an already configured target.
+- Strategy: inspect capabilities and health, select the configured reachable endpoint, submit one deterministic preset to the serialized Windows queue, observe terminal state, and download only when requested.
+- Output: structured CLI evidence, a job identifier and state, and for completed processing an explicitly requested local output file.
+
+## Main Line
+
+1. Run `topazlabscli capabilities --json` when the live contract is not already known.
+2. Run `topazlabscli doctor --json` before the first job in a conversation or after a connection/model failure.
+3. For a processing request, confirm the input exists and the output path is authorized.
+4. Prefer `topazlabscli process INPUT --output OUTPUT --json` for submit, wait, and download as one operation. Use separate `job` commands when the user wants asynchronous control.
+5. Inspect the final JSON. Completion requires `state=completed`, a successful download result, and a real local output file.
+6. Report the selected target/endpoint, job ID, output path, preset/model, dimensions, and any warning or failure.
+
+## Preset Boundary
+
+`seedance-human-1080p` is the only built-in preset in version 0.1. It uses Proteus v4 (`prob-4`), preserves source FPS and aspect ratio, targets a 1080-pixel short edge, and relies on the remote queue's single concurrency slot. Do not silently substitute another model, frame interpolation, stabilization, motion deblur, or 4K output.
+
+## Branches
+
+- Connection failure: report `CONNECTION_FAILED` and the endpoint attempts. The CLI does not start, reconfigure, or grant access to a VPN.
+- Worker/model not ready: run `worker status` or `model status`; stop with the returned dependency error. Installing/licensing Topaz and downloading models remain GUI administration tasks.
+- Long-running work: use `job submit`, return the job ID, then `job wait` when the user asks to remain attached. Do not resubmit merely because a wait timed out.
+- Cancellation: queued work may cancel immediately. A running task records a cancellation request but is not forcibly killed in version 0.1.
+- Missing capability: return `CAPABILITY_UNAVAILABLE` or the CLI's structured error. Do not invent a platform-specific workaround.
+
+## Configuration and Safety
+
+Configuration, hostnames, addresses, usernames, SSH identities, VPN details, media, Topaz binaries, models, and credentials are external to this Skill and npm package. Installation does not grant access to a workstation. Treat the configured server and Topaz license as user-managed resources.
+
+Do not overwrite a local output unless the user has authorized that exact existing target. The remote worker retains job inputs, outputs, status, and logs for operator review; cleanup is an administrative action outside version 0.1.
+
+## Skill Management
+
+The npm package is the canonical source. Discover it with `topazlabscli skill source --json`; use `skill status`, `skill install`, and `skill update` for Codex and SealSeek targets. Do not edit installed links or copies as independent sources.
+
+## QA and Evolution
+
+Use `doctor --json` plus the final job status as runtime evidence. Treat Codex and SealSeek adapters as `implemented` until each has a recorded real runtime test. New models, presets, cleanup rules, or worker behavior require an authorized package update with CLI, worker, Skill, capability, and test changes together.

package/skill/topazlabscli/adapters/codex.json

@@ -0,0 +1,29 @@
+{
+  "schema": "portable-skill-adapter",
+  "schema_version": "1.0.0",
+  "platform": "codex",
+  "mappings": [
+    {
+      "capability_id": "command.execute",
+      "implementation": { "kind": "cli", "command": "topazlabscli" },
+      "features": ["local-process", "stdout-json", "exit-code"],
+      "status": "tested",
+      "tested_date": "2026-09-20",
+      "evidence": ["Codex invoked topazlabscli process --json through the local terminal and received a completed remote job contract."],
+      "configuration": ["topazlabscli must resolve from PATH"],
+      "permissions": ["local process execution", "network access to configured SSH target"],
+      "normalization": "Invoke with --json and consume {ok,data,error}."
+    },
+    {
+      "capability_id": "filesystem.local",
+      "implementation": { "kind": "agent-native", "name": "Codex filesystem tools" },
+      "features": ["read-file", "write-file", "inspect-metadata"],
+      "status": "tested",
+      "tested_date": "2026-09-20",
+      "evidence": ["Codex verified the downloaded MP4 with local ffprobe after the end-to-end job completed."],
+      "configuration": [],
+      "permissions": ["input and output paths must be within the user's authorized scope"],
+      "normalization": "Return absolute local paths and verified metadata."
+    }
+  ]
+}

package/skill/topazlabscli/adapters/sealseek.json

@@ -0,0 +1,25 @@
+{
+  "schema": "portable-skill-adapter",
+  "schema_version": "1.0.0",
+  "platform": "sealseek",
+  "mappings": [
+    {
+      "capability_id": "command.execute",
+      "implementation": { "kind": "cli", "command": "topazlabscli" },
+      "features": ["local-process", "stdout-json", "exit-code"],
+      "status": "implemented",
+      "configuration": ["topazlabscli must resolve from PATH"],
+      "permissions": ["local process execution", "network access to configured SSH target"],
+      "normalization": "Invoke with --json and consume {ok,data,error}."
+    },
+    {
+      "capability_id": "filesystem.local",
+      "implementation": { "kind": "agent-native", "name": "SealSeek/OpenClaw filesystem capability" },
+      "features": ["read-file", "write-file", "inspect-metadata"],
+      "status": "implemented",
+      "configuration": [],
+      "permissions": ["input and output paths must be within the user's authorized scope"],
+      "normalization": "Return absolute local paths and verified metadata."
+    }
+  ]
+}

package/skill/topazlabscli/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "TopazLabs CLI"
+  short_description: "Queue remote Topaz Video AI enhancement jobs"
+  default_prompt: "Use topazlabscli to check the configured workstation and process a video safely."

package/skill/topazlabscli/capabilities.json

@@ -0,0 +1,36 @@
+{
+  "schema": "portable-skill-capabilities",
+  "schema_version": "1.0.0",
+  "skill": "topazlabscli",
+  "target_platforms": ["codex", "sealseek"],
+  "capabilities": [
+    {
+      "id": "command.execute",
+      "purpose": "Run the stable topazlabscli executable and parse JSON results.",
+      "required": true,
+      "required_features": ["local-process", "stdout-json", "exit-code"],
+      "input_fields": ["argv"],
+      "output_fields": ["ok", "data", "error"],
+      "side_effects": {
+        "external_mutation": "May upload videos and enqueue remote processing only when the user requests processing.",
+        "may_cost_money": false,
+        "authorization": "Requires the user's configured SSH access and an explicit processing request."
+      },
+      "standard_errors": ["CAPABILITY_UNAVAILABLE", "AUTH_REQUIRED", "PERMISSION_REQUIRED", "PROVIDER_FAILURE", "OUTPUT_CONTRACT_FAILED"]
+    },
+    {
+      "id": "filesystem.local",
+      "purpose": "Read input videos and write downloaded outputs.",
+      "required": true,
+      "required_features": ["read-file", "write-file", "inspect-metadata"],
+      "input_fields": ["path"],
+      "output_fields": ["exists", "path", "size"],
+      "side_effects": {
+        "external_mutation": "Writes only to the output path requested by the user.",
+        "may_cost_money": false,
+        "authorization": "The path must be within the user's authorized filesystem scope."
+      },
+      "standard_errors": ["CAPABILITY_UNAVAILABLE", "PERMISSION_REQUIRED", "OUTPUT_CONTRACT_FAILED"]
+    }
+  ]
+}

package/src/cli.mjs

@@ -0,0 +1,285 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { createRequire } from "node:module";
+import { loadConfig, saveConfig, resolveTarget } from "./config.mjs";
+import { configPath, workerScript } from "./paths.mjs";
+import { CliError, requireValue } from "./errors.mjs";
+import { run } from "./process.mjs";
+import { psLiteral, runPowerShell, selectEndpoint, sftpGet, sftpPut, startPowerShellDetached } from "./ssh.mjs";
+import { skillInstall, skillSource, skillStatus } from "./skill.mjs";
+
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+const PRESET = "seedance-human-1080p";
+
+const CAPABILITIES = {
+  schema_version: 1,
+  package: pkg.name,
+  version: pkg.version,
+  commands: ["version", "capabilities", "doctor", "target", "connection", "worker", "model", "job", "process", "skill", "update"],
+  presets: [{ id: PRESET, model: "prob-4", output: "aspect-preserving 1080p", fps: "source", concurrency: 1 }],
+  agents: { codex: "tested", sealseek: "implemented" },
+  worker_os: ["windows"],
+  transport: ["ssh", "sftp"]
+};
+
+function option(args, name, { multiple = false } = {}) {
+  const values = [];
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === name) {
+      if (i + 1 >= args.length) throw new CliError("ARGUMENT_REQUIRED", `${name} requires a value.`);
+      values.push(args[i + 1]);
+      args.splice(i, 2);
+      i -= 1;
+    } else if (args[i].startsWith(`${name}=`)) {
+      values.push(args[i].slice(name.length + 1));
+      args.splice(i, 1);
+      i -= 1;
+    }
+  }
+  return multiple ? values : values.at(-1);
+}
+
+function flag(args, name) {
+  const index = args.indexOf(name);
+  if (index < 0) return false;
+  args.splice(index, 1);
+  return true;
+}
+
+function output(value, json) {
+  if (json) process.stdout.write(`${JSON.stringify({ ok: true, data: value }, null, 2)}\n`);
+  else if (typeof value === "string") process.stdout.write(`${value}\n`);
+  else process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+function help() {
+  return `topazlabscli ${pkg.version}\n\n` +
+    `Commands:\n` +
+    `  version | capabilities | doctor\n` +
+    `  target add <name> --endpoint <label=host>... --user <user> [--identity <path>] [--workspace <windows-path>] [--default]\n` +
+    `  target list\n` +
+    `  connection check [--target <name>]\n` +
+    `  worker install|status [--target <name>]\n` +
+    `  model status [--target <name>]\n` +
+    `  job submit <video> [--target <name>] [--preset ${PRESET}]\n` +
+    `  job list [--target <name>]\n` +
+    `  job status|wait|download|cancel <job-id> [--target <name>] [--output <path>]\n` +
+    `  process <video> --output <path> [--target <name>]\n` +
+    `  skill source|status|install|update [--agent codex|sealseek|all] [--copy]\n` +
+    `  update\n\nUse --json for machine-readable output.`;
+}
+
+function parseEndpoint(value) {
+  const split = value.indexOf("=");
+  const name = split > 0 ? value.slice(0, split) : "default";
+  const address = split > 0 ? value.slice(split + 1) : value;
+  const match = address.match(/^(.+?)(?::(\d+))?$/);
+  if (!match || !match[1]) throw new CliError("ENDPOINT_INVALID", `Invalid endpoint: ${value}`);
+  return { name, host: match[1], ...(match[2] ? { port: Number(match[2]) } : {}) };
+}
+
+function remoteRoot(target) {
+  return target.workspace || "E:\\topazlab_workspace";
+}
+
+function workerInvocation(root, action, extra = "") {
+  const script = `${root}\\.topazlabscli\\worker\\topazlabs-worker.ps1`;
+  return `& ${psLiteral(script)} -Action ${psLiteral(action)} -Root ${psLiteral(root)} ${extra}`;
+}
+
+function parseRemoteJson(result, code = "REMOTE_ERROR") {
+  if (result.code !== 0) throw new CliError(code, result.stderr.trim() || result.stdout.trim() || "Remote command failed.");
+  const text = result.stdout.trim();
+  try { return JSON.parse(text); }
+  catch { throw new CliError("REMOTE_OUTPUT_INVALID", "Remote worker did not return valid JSON.", { output: text }); }
+}
+
+async function remoteAction(target, endpoint, action, params = {}) {
+  const encoded = Buffer.from(JSON.stringify(params), "utf8").toString("base64");
+  const extra = Object.keys(params).length ? `-PayloadBase64 ${psLiteral(encoded)}` : "";
+  return parseRemoteJson(await runPowerShell(target, endpoint, workerInvocation(remoteRoot(target), action, extra)));
+}
+
+async function getConnectedTarget(requested) {
+  const target = resolveTarget(loadConfig({ required: true }), requested);
+  const selected = await selectEndpoint(target);
+  return { target, ...selected };
+}
+
+async function submitJob(inputPath, requestedTarget, preset = PRESET) {
+  const input = path.resolve(inputPath);
+  if (!fs.existsSync(input) || !fs.statSync(input).isFile()) throw new CliError("INPUT_NOT_FOUND", `Video not found: ${input}`);
+  if (preset !== PRESET) throw new CliError("PRESET_UNSUPPORTED", `Unsupported preset: ${preset}`);
+  const { target, endpoint, attempts } = await getConnectedTarget(requestedTarget);
+  const id = `${new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14)}-${crypto.randomBytes(3).toString("hex")}`;
+  const safeName = path.basename(input).replace(/[^A-Za-z0-9._-]/g, "_");
+  const prepared = await remoteAction(target, endpoint, "Prepare", { id, input_name: safeName });
+  await sftpPut(target, endpoint, input, prepared.input_path);
+  const job = await remoteAction(target, endpoint, "Enqueue", { id, input_name: safeName, preset });
+  const runnerPid = startPowerShellDetached(target, endpoint, workerInvocation(remoteRoot(target), "Run"));
+  return { ...job, target: target.name, endpoint: endpoint.name, runner_pid: runnerPid, connection_attempts: attempts };
+}
+
+async function waitJob(id, requestedTarget, intervalSeconds = 10, timeoutSeconds = 86400) {
+  const { target, endpoint } = await getConnectedTarget(requestedTarget);
+  const started = Date.now();
+  while (true) {
+    const status = await remoteAction(target, endpoint, "JobStatus", { id });
+    if (["completed", "failed", "cancelled"].includes(status.state)) return { ...status, target: target.name, endpoint: endpoint.name };
+    if ((Date.now() - started) / 1000 > timeoutSeconds) throw new CliError("WAIT_TIMEOUT", `Timed out waiting for job ${id}.`);
+    await new Promise((resolve) => setTimeout(resolve, intervalSeconds * 1000));
+  }
+}
+
+async function downloadJob(id, requestedTarget, outputPath) {
+  const { target, endpoint } = await getConnectedTarget(requestedTarget);
+  const status = await remoteAction(target, endpoint, "JobStatus", { id });
+  if (status.state !== "completed") throw new CliError("JOB_NOT_COMPLETE", `Job ${id} is ${status.state}.`);
+  const destination = path.resolve(outputPath || status.output_name || `${id}.mp4`);
+  if (fs.existsSync(destination)) throw new CliError("OUTPUT_EXISTS", `Refusing to overwrite existing output: ${destination}`);
+  await sftpGet(target, endpoint, status.output_path, destination);
+  return { id, target: target.name, endpoint: endpoint.name, output: destination };
+}
+
+async function doctor(requestedTarget) {
+  const checks = [];
+  for (const command of ["ssh", "sftp", "node", "npm"]) {
+    const args = command === "node" || command === "npm" ? ["--version"] : command === "sftp" ? ["-h"] : ["-V"];
+    const result = await run(command, args);
+    const detail = (result.stdout || result.stderr).trim().split("\n")[0];
+    const ok = result.code === 0 || (command === "sftp" && /usage:\s*sftp/i.test(result.stderr));
+    checks.push({ id: `local.${command}`, ok, detail });
+  }
+  checks.push({ id: "config", ok: fs.existsSync(configPath()), detail: configPath() });
+  if (requestedTarget || fs.existsSync(configPath())) {
+    try {
+      const { target, endpoint } = await getConnectedTarget(requestedTarget);
+      checks.push({ id: "connection", ok: true, detail: `${target.name}/${endpoint.name}` });
+      try {
+        const status = await remoteAction(target, endpoint, "Status");
+        checks.push({ id: "worker", ok: Boolean(status.installed), detail: status });
+      } catch (error) {
+        checks.push({ id: "worker", ok: false, detail: error.message });
+      }
+    } catch (error) {
+      checks.push({ id: "connection", ok: false, detail: error.details || error.message });
+    }
+  }
+  return { ok: checks.every((item) => item.ok), checks };
+}
+
+export async function main(rawArgs) {
+  const args = [...rawArgs];
+  const json = flag(args, "--json");
+  if (args.length === 0 || ["help", "--help", "-h"].includes(args[0])) return output(help(), false);
+  const command = args.shift();
+  if (command === "version" || command === "--version" || command === "-V") return output(pkg.version, json);
+  if (command === "capabilities") return output(CAPABILITIES, json);
+  if (command === "doctor") return output(await doctor(option(args, "--target")), json);
+
+  if (command === "target") {
+    const action = args.shift();
+    if (action === "list") return output({ path: configPath(), ...loadConfig() }, json);
+    if (action === "add") {
+      const name = requireValue(args.shift(), "TARGET_REQUIRED", "target add requires a name.");
+      const endpoints = option(args, "--endpoint", { multiple: true }).map(parseEndpoint);
+      if (endpoints.length === 0) throw new CliError("ENDPOINT_REQUIRED", "Provide at least one --endpoint label=host.");
+      const config = loadConfig();
+      config.targets[name] = {
+        user: option(args, "--user") || null,
+        identity_file: option(args, "--identity") || null,
+        workspace: option(args, "--workspace") || "E:\\topazlab_workspace",
+        endpoints
+      };
+      if (flag(args, "--default") || !config.default_target) config.default_target = name;
+      const saved = saveConfig(config);
+      return output({ name, path: saved, target: config.targets[name], default: config.default_target === name }, json);
+    }
+    throw new CliError("COMMAND_UNKNOWN", `Unknown target action: ${action || ""}`);
+  }
+
+  if (command === "connection" && args.shift() === "check") {
+    const { target, endpoint, attempts } = await getConnectedTarget(option(args, "--target"));
+    return output({ target: target.name, selected: endpoint, attempts }, json);
+  }
+
+  if (command === "worker") {
+    const action = args.shift();
+    const requested = option(args, "--target");
+    const { target, endpoint, attempts } = await getConnectedTarget(requested);
+    if (action === "install") {
+      const root = remoteRoot(target);
+      const remote = `${root}\\.topazlabscli\\worker\\topazlabs-worker.ps1`;
+      const workerDirectory = `${root}\\.topazlabscli\\worker`;
+      const prep = `$p=${psLiteral(workerDirectory)}; New-Item -ItemType Directory -Force -Path $p | Out-Null; [Console]::Out.Write('{"ok":true}')`;
+      parseRemoteJson(await runPowerShell(target, endpoint, prep));
+      await sftpPut(target, endpoint, workerScript, remote);
+      const installed = await remoteAction(target, endpoint, "Install");
+      return output({ ...installed, target: target.name, endpoint: endpoint.name, connection_attempts: attempts }, json);
+    }
+    if (action === "status") return output(await remoteAction(target, endpoint, "Status"), json);
+    throw new CliError("COMMAND_UNKNOWN", `Unknown worker action: ${action || ""}`);
+  }
+
+  if (command === "model" && args.shift() === "status") {
+    const { target, endpoint } = await getConnectedTarget(option(args, "--target"));
+    const status = await remoteAction(target, endpoint, "Status");
+    return output({ model: "prob-4", ready: status.model_ready, definitions: status.model_definitions, weights: status.model_weights }, json);
+  }
+
+  if (command === "job") {
+    const action = args.shift();
+    const requested = option(args, "--target");
+    if (action === "submit") return output(await submitJob(requireValue(args.shift(), "INPUT_REQUIRED", "job submit requires a video."), requested, option(args, "--preset") || PRESET), json);
+    if (action === "list") {
+      const { target, endpoint } = await getConnectedTarget(requested);
+      return output(await remoteAction(target, endpoint, "ListJobs"), json);
+    }
+    const id = requireValue(args.shift(), "JOB_ID_REQUIRED", `job ${action || ""} requires a job id.`);
+    if (action === "status") {
+      const { target, endpoint } = await getConnectedTarget(requested);
+      return output(await remoteAction(target, endpoint, "JobStatus", { id }), json);
+    }
+    if (action === "wait") return output(await waitJob(id, requested, Number(option(args, "--interval") || 10), Number(option(args, "--timeout") || 86400)), json);
+    if (action === "download") return output(await downloadJob(id, requested, option(args, "--output")), json);
+    if (action === "cancel") {
+      const { target, endpoint } = await getConnectedTarget(requested);
+      return output(await remoteAction(target, endpoint, "Cancel", { id }), json);
+    }
+    throw new CliError("COMMAND_UNKNOWN", `Unknown job action: ${action || ""}`);
+  }
+
+  if (command === "process") {
+    const input = requireValue(args.shift(), "INPUT_REQUIRED", "process requires a video.");
+    const destination = requireValue(option(args, "--output"), "OUTPUT_REQUIRED", "process requires --output.");
+    const requested = option(args, "--target");
+    const submitted = await submitJob(input, requested, option(args, "--preset") || PRESET);
+    const finished = await waitJob(submitted.id, requested, Number(option(args, "--interval") || 10), Number(option(args, "--timeout") || 86400));
+    if (finished.state !== "completed") throw new CliError("JOB_FAILED", `Job ${submitted.id} ended as ${finished.state}.`, finished);
+    return output({ submitted, finished, downloaded: await downloadJob(submitted.id, requested, destination) }, json);
+  }
+
+  if (command === "skill") {
+    const action = args.shift();
+    const agent = option(args, "--agent") || "all";
+    if (action === "source") return output(skillSource(), json);
+    if (action === "status") return output(skillStatus(agent), json);
+    if (action === "install") return output(skillInstall(agent, flag(args, "--copy") ? "copy" : "link", false), json);
+    if (action === "update") return output(skillInstall(agent, flag(args, "--copy") ? "copy" : "link", true), json);
+    throw new CliError("COMMAND_UNKNOWN", `Unknown skill action: ${action || ""}`);
+  }
+
+  if (command === "update") {
+    const previousSkills = skillStatus("all");
+    const result = await run("npm", ["install", "-g", `${pkg.name}@latest`]);
+    if (result.code !== 0) throw new CliError("UPDATE_FAILED", result.stderr.trim() || "npm update failed.");
+    const skills = [];
+    for (const existing of previousSkills.filter((item) => item.installed)) {
+      skills.push(...skillInstall(existing.agent, existing.mode || "link", true));
+    }
+    return output({ package: pkg.name, updated: true, skills, detail: result.stdout.trim() }, json);
+  }
+  throw new CliError("COMMAND_UNKNOWN", `Unknown command: ${command}`);
+}

package/src/config.mjs

@@ -0,0 +1,47 @@
+import fs from "node:fs";
+import path from "node:path";
+import { configPath } from "./paths.mjs";
+import { CliError } from "./errors.mjs";
+
+export function emptyConfig() {
+  return { schema_version: 1, default_target: null, targets: {} };
+}
+
+export function loadConfig({ required = false } = {}) {
+  const filename = configPath();
+  if (!fs.existsSync(filename)) {
+    if (required) throw new CliError("CONFIG_NOT_FOUND", `Configuration not found: ${filename}`);
+    return emptyConfig();
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filename, "utf8"));
+    if (parsed.schema_version !== 1 || typeof parsed.targets !== "object") {
+      throw new Error("unsupported configuration schema");
+    }
+    return parsed;
+  } catch (error) {
+    throw new CliError("CONFIG_INVALID", `Cannot read configuration: ${error.message}`, { path: filename });
+  }
+}
+
+export function saveConfig(config) {
+  const filename = configPath();
+  fs.mkdirSync(path.dirname(filename), { recursive: true, mode: 0o700 });
+  if (fs.existsSync(filename)) fs.copyFileSync(filename, `${filename}.bak`);
+  const temporary = `${filename}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+  fs.renameSync(temporary, filename);
+  try { fs.chmodSync(filename, 0o600); } catch {}
+  return filename;
+}
+
+export function resolveTarget(config, requested) {
+  const name = requested || config.default_target;
+  if (!name) throw new CliError("TARGET_REQUIRED", "Specify --target or configure a default target.");
+  const target = config.targets[name];
+  if (!target) throw new CliError("TARGET_NOT_FOUND", `Unknown target: ${name}`);
+  if (!Array.isArray(target.endpoints) || target.endpoints.length === 0) {
+    throw new CliError("TARGET_INVALID", `Target ${name} has no endpoints.`);
+  }
+  return { name, ...target };
+}

package/src/errors.mjs

@@ -0,0 +1,16 @@
+export class CliError extends Error {
+  constructor(code, message, details = null, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+    this.details = details;
+    this.exitCode = exitCode;
+  }
+}
+
+export function requireValue(value, code, message) {
+  if (value === undefined || value === null || value === "") {
+    throw new CliError(code, message);
+  }
+  return value;
+}

package/src/paths.mjs

@@ -0,0 +1,27 @@
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+export const packageRoot = path.resolve(here, "..");
+export const bundledSkill = path.join(packageRoot, "skill", "topazlabscli");
+export const workerScript = path.join(packageRoot, "worker", "windows", "topazlabs-worker.ps1");
+
+export function configPath() {
+  if (process.env.TOPAZLABSCLI_CONFIG) return path.resolve(process.env.TOPAZLABSCLI_CONFIG);
+  const base = process.platform === "win32"
+    ? (process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"))
+    : (process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"));
+  return path.join(base, "topazlabscli", "config.json");
+}
+
+export function skillTarget(agent) {
+  const home = os.homedir();
+  if (agent === "codex") {
+    return path.join(process.env.CODEX_HOME || path.join(home, ".codex"), "skills", "topazlabscli");
+  }
+  if (agent === "sealseek") {
+    return path.join(process.env.SEALSEEK_SKILLS_HOME || path.join(home, ".agents", "skills"), "topazlabscli");
+  }
+  throw new Error(`Unknown Agent: ${agent}`);
+}

package/src/process.mjs

@@ -0,0 +1,21 @@
+import { spawn } from "node:child_process";
+
+export function run(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      stdio: [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => { stdout += chunk; });
+    child.stderr.on("data", (chunk) => { stderr += chunk; });
+    child.on("error", reject);
+    child.on("close", (code, signal) => resolve({ code, signal, stdout, stderr }));
+    if (options.input !== undefined) {
+      child.stdin.end(options.input);
+    }
+  });
+}

package/src/skill.mjs

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import path from "node:path";
+import { bundledSkill, skillTarget } from "./paths.mjs";
+import { CliError } from "./errors.mjs";
+
+const agents = ["codex", "sealseek"];
+
+export function skillSource() {
+  return { path: bundledSkill, exists: fs.existsSync(path.join(bundledSkill, "SKILL.md")) };
+}
+
+export function skillStatus(selected = "all") {
+  const names = selected === "all" ? agents : [selected];
+  return names.map((agent) => {
+    const target = skillTarget(agent);
+    let installed = false;
+    let mode = null;
+    if (fs.existsSync(target)) {
+      installed = true;
+      mode = fs.lstatSync(target).isSymbolicLink() ? "link" : "copy";
+    }
+    return { agent, target, installed, mode, source: bundledSkill };
+  });
+}
+
+function installOne(agent, mode, update) {
+  const target = skillTarget(agent);
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  if (fs.existsSync(target)) {
+    if (!update) throw new CliError("SKILL_ALREADY_INSTALLED", `Skill target already exists: ${target}`);
+    const stat = fs.lstatSync(target);
+    if (stat.isSymbolicLink()) fs.unlinkSync(target);
+    else fs.rmSync(target, { recursive: true, force: true });
+  }
+  if (mode === "copy") fs.cpSync(bundledSkill, target, { recursive: true });
+  else fs.symlinkSync(bundledSkill, target, process.platform === "win32" ? "junction" : "dir");
+  return { agent, target, mode };
+}
+
+export function skillInstall(selected = "all", mode = "link", update = false) {
+  const names = selected === "all" ? agents : [selected];
+  for (const name of names) if (!agents.includes(name)) throw new CliError("AGENT_UNSUPPORTED", `Unsupported Agent: ${name}`);
+  return names.map((name) => installOne(name, mode, update));
+}

package/src/ssh.mjs

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { run } from "./process.mjs";
+import { CliError } from "./errors.mjs";
+
+function destination(target, endpoint) {
+  return target.user ? `${target.user}@${endpoint.host}` : endpoint.host;
+}
+
+function commonArgs(target, endpoint, { timeout = 7 } = {}) {
+  const args = ["-o", "BatchMode=yes", "-o", `ConnectTimeout=${timeout}`];
+  if (target.identity_file) args.push("-i", target.identity_file);
+  if (endpoint.port) args.push("-p", String(endpoint.port));
+  return args;
+}
+
+export function encodePowerShell(script) {
+  return Buffer.from(script, "utf16le").toString("base64");
+}
+
+export async function runPowerShell(target, endpoint, script, { timeout = 7 } = {}) {
+  const args = [...commonArgs(target, endpoint, { timeout }), destination(target, endpoint),
+    "powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-EncodedCommand", encodePowerShell(script)];
+  return run("ssh", args);
+}
+
+export function startPowerShellDetached(target, endpoint, script) {
+  const args = [...commonArgs(target, endpoint, { timeout: 10 }), destination(target, endpoint),
+    "powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-EncodedCommand", encodePowerShell(script)];
+  const child = spawn("ssh", args, { detached: true, stdio: "ignore", windowsHide: true });
+  child.unref();
+  return child.pid;
+}
+
+export async function selectEndpoint(target) {
+  const attempts = [];
+  for (const endpoint of target.endpoints) {
+    const result = await runPowerShell(target, endpoint, "[Console]::Out.Write('TOPAZLABSCLI_OK')");
+    const ok = result.code === 0 && result.stdout.includes("TOPAZLABSCLI_OK");
+    attempts.push({ name: endpoint.name, host: endpoint.host, ok, error: ok ? null : result.stderr.trim() });
+    if (ok) return { endpoint, attempts };
+  }
+  throw new CliError("CONNECTION_FAILED", `No endpoint is reachable for target ${target.name}.`, { attempts });
+}
+
+function quoteSftp(value) {
+  return `"${String(value).replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+
+export function windowsToSftp(remotePath) {
+  const normalized = String(remotePath).replaceAll("\\", "/");
+  if (/^[A-Za-z]:\//.test(normalized)) return `/${normalized}`;
+  return normalized;
+}
+
+export async function sftpPut(target, endpoint, localPath, remotePath) {
+  if (!fs.existsSync(localPath)) throw new CliError("INPUT_NOT_FOUND", `Local file not found: ${localPath}`);
+  const args = ["-b", "-", "-o", "BatchMode=yes", "-o", "ConnectTimeout=10"];
+  if (target.identity_file) args.push("-i", target.identity_file);
+  if (endpoint.port) args.push("-P", String(endpoint.port));
+  args.push(destination(target, endpoint));
+  const input = `put ${quoteSftp(path.resolve(localPath))} ${quoteSftp(windowsToSftp(remotePath))}\n`;
+  const result = await run("sftp", args, { input });
+  if (result.code !== 0) throw new CliError("UPLOAD_FAILED", result.stderr.trim() || "SFTP upload failed.");
+  return result;
+}
+
+export async function sftpGet(target, endpoint, remotePath, localPath) {
+  fs.mkdirSync(path.dirname(path.resolve(localPath)), { recursive: true });
+  const args = ["-b", "-", "-o", "BatchMode=yes", "-o", "ConnectTimeout=10"];
+  if (target.identity_file) args.push("-i", target.identity_file);
+  if (endpoint.port) args.push("-P", String(endpoint.port));
+  args.push(destination(target, endpoint));
+  const input = `get ${quoteSftp(windowsToSftp(remotePath))} ${quoteSftp(path.resolve(localPath))}\n`;
+  const result = await run("sftp", args, { input });
+  if (result.code !== 0) throw new CliError("DOWNLOAD_FAILED", result.stderr.trim() || "SFTP download failed.");
+  return result;
+}
+
+export function psLiteral(value) {
+  return `'${String(value).replaceAll("'", "''")}'`;
+}

package/worker/windows/topazlabs-worker.ps1

@@ -0,0 +1,237 @@
+param(
+  [Parameter(Mandatory = $true)]
+  [ValidateSet('Install', 'Status', 'Prepare', 'Enqueue', 'Run', 'JobStatus', 'ListJobs', 'Cancel')]
+  [string]$Action,
+  [Parameter(Mandatory = $true)]
+  [string]$Root,
+  [string]$PayloadBase64
+)
+
+$ErrorActionPreference = 'Stop'
+$WorkerVersion = '0.1.0'
+$StateRoot = Join-Path $Root '.topazlabscli'
+$QueueRoot = Join-Path $StateRoot 'queue'
+$JobsRoot = Join-Path $StateRoot 'jobs'
+$WorkerRoot = Join-Path $StateRoot 'worker'
+$ConfigPath = Join-Path $StateRoot 'worker-config.json'
+
+function Write-Json($Value) {
+  [Console]::Out.Write(($Value | ConvertTo-Json -Depth 8 -Compress))
+}
+
+function Read-Payload {
+  if ([string]::IsNullOrWhiteSpace($PayloadBase64)) { return @{} }
+  $json = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($PayloadBase64))
+  return $json | ConvertFrom-Json
+}
+
+function Ensure-Directories {
+  @($StateRoot, $QueueRoot, $JobsRoot, $WorkerRoot) | ForEach-Object {
+    New-Item -ItemType Directory -Force -Path $_ | Out-Null
+  }
+}
+
+function Assert-SafeName([string]$Value, [string]$Field) {
+  if ([string]::IsNullOrWhiteSpace($Value) -or $Value -notmatch '^[A-Za-z0-9._-]+$') {
+    throw "Invalid $Field."
+  }
+}
+
+function Read-WorkerConfig {
+  if (-not (Test-Path -LiteralPath $ConfigPath)) { throw 'Worker is not installed.' }
+  return Get-Content -Raw -LiteralPath $ConfigPath | ConvertFrom-Json
+}
+
+function Job-Directory([string]$Id) {
+  Assert-SafeName $Id 'job id'
+  return Join-Path $JobsRoot $Id
+}
+
+function Status-Path([string]$Id) {
+  return Join-Path (Job-Directory $Id) 'status.json'
+}
+
+function Set-JobStatus([string]$Id, [hashtable]$Values) {
+  $path = Status-Path $Id
+  $current = @{}
+  if (Test-Path -LiteralPath $path) {
+    $existing = Get-Content -Raw -LiteralPath $path | ConvertFrom-Json
+    $existing.PSObject.Properties | ForEach-Object { $current[$_.Name] = $_.Value }
+  }
+  $Values.Keys | ForEach-Object { $current[$_] = $Values[$_] }
+  $current['id'] = $Id
+  $current['updated_at'] = (Get-Date).ToUniversalTime().ToString('o')
+  $temporary = "$path.tmp"
+  $current | ConvertTo-Json -Depth 8 | Set-Content -LiteralPath $temporary -Encoding UTF8
+  Move-Item -Force -LiteralPath $temporary -Destination $path
+  return $current
+}
+
+function Get-ModelStatus($Config) {
+  $definition = Join-Path $Config.model_dir 'prob-4.json'
+  $weights = @(Get-ChildItem -LiteralPath $Config.model_data_dir -Filter 'prob-v4-*.tz' -ErrorAction SilentlyContinue)
+  return @{
+    model_ready = ((Test-Path -LiteralPath $definition) -and $weights.Count -gt 0)
+    model_definitions = @{ path = $definition; exists = (Test-Path -LiteralPath $definition) }
+    model_weights = @{ path = $Config.model_data_dir; count = $weights.Count }
+  }
+}
+
+function Invoke-Job($Job, $Config) {
+  $id = [string]$Job.id
+  $jobDir = Job-Directory $id
+  $inputPath = Join-Path (Join-Path $jobDir 'input') ([string]$Job.input_name)
+  $outputDir = Join-Path $jobDir 'output'
+  $outputName = ([IO.Path]::GetFileNameWithoutExtension([string]$Job.input_name)) + '-topaz-1080p.mp4'
+  $outputPath = Join-Path $outputDir $outputName
+  $logPath = Join-Path (Join-Path $jobDir 'logs') 'topaz-ffmpeg.log'
+  if (-not (Test-Path -LiteralPath $inputPath)) { throw "Input file is missing: $inputPath" }
+  if (-not (Test-Path -LiteralPath $Config.ffmpeg)) { throw "Topaz ffmpeg is missing: $($Config.ffmpeg)" }
+
+  Set-JobStatus $id @{ state = 'running'; started_at = (Get-Date).ToUniversalTime().ToString('o'); input_path = $inputPath; output_path = $outputPath; output_name = $outputName; preset = $Job.preset } | Out-Null
+  $probeText = & $Config.ffprobe -v error -select_streams v:0 -show_entries stream=width,height -of json -- $inputPath
+  if ($LASTEXITCODE -ne 0) { throw 'ffprobe failed.' }
+  $probe = $probeText | ConvertFrom-Json
+  $width = [int]$probe.streams[0].width
+  $height = [int]$probe.streams[0].height
+  if ($width -ge $height) {
+    $targetHeight = 1080
+    $targetWidth = [int](2 * [Math]::Round((1080.0 * $width / $height) / 2.0))
+  } else {
+    $targetWidth = 1080
+    $targetHeight = [int](2 * [Math]::Round((1080.0 * $height / $width) / 2.0))
+  }
+  $env:TVAI_MODEL_DIR = [string]$Config.model_dir
+  $env:TVAI_MODEL_DATA_DIR = [string]$Config.model_data_dir
+  $filter = "tvai_up=model=prob-4:scale=0:w=${targetWidth}:h=${targetHeight}:preblur=0:noise=0:details=0:halo=0:blur=0:compression=0:estimate=20:blend=0.2:device=0:vram=1:instances=1"
+  $arguments = @(
+    '-hide_banner', '-nostdin', '-y', '-strict', '2', '-i', $inputPath,
+    '-sws_flags', 'spline+accurate_rnd+full_chroma_int', '-vf', $filter,
+    '-map', '0:v:0', '-map', '0:a?', '-map_metadata', '0',
+    '-c:v', 'h264_nvenc', '-preset', 'p5', '-cq', '18', '-b:v', '0', '-pix_fmt', 'yuv420p',
+    '-c:a', 'aac', '-b:a', '192k', '-fps_mode', 'passthrough', '-movflags', '+faststart', $outputPath
+  )
+  $oldPreference = $ErrorActionPreference
+  $ErrorActionPreference = 'Continue'
+  & $Config.ffmpeg @arguments 2>&1 | Tee-Object -FilePath $logPath | Out-Null
+  $exit = $LASTEXITCODE
+  $ErrorActionPreference = $oldPreference
+  if ($exit -ne 0 -or -not (Test-Path -LiteralPath $outputPath)) { throw "Topaz ffmpeg failed with exit code $exit. See $logPath" }
+  $size = (Get-Item -LiteralPath $outputPath).Length
+  Set-JobStatus $id @{ state = 'completed'; completed_at = (Get-Date).ToUniversalTime().ToString('o'); output_path = $outputPath; output_name = $outputName; output_bytes = $size; width = $targetWidth; height = $targetHeight; model = 'prob-4' } | Out-Null
+}
+
+Ensure-Directories
+
+switch ($Action) {
+  'Install' {
+    if (-not (Test-Path -LiteralPath $ConfigPath)) {
+      $config = @{
+        schema_version = 1
+        worker_version = $WorkerVersion
+        ffmpeg = 'C:\Program Files\Topaz Labs LLC\Topaz Video AI\ffmpeg.exe'
+        ffprobe = 'C:\Program Files\Topaz Labs LLC\Topaz Video AI\ffprobe.exe'
+        model_dir = 'C:\ProgramData\Topaz Labs LLC\Topaz Video AI\models'
+        model_data_dir = 'E:\topazlabs_model'
+        concurrency = 1
+      }
+      $config | ConvertTo-Json | Set-Content -LiteralPath $ConfigPath -Encoding UTF8
+    }
+    $current = Read-WorkerConfig
+    $model = Get-ModelStatus $current
+    Write-Json @{ ok = $true; installed = $true; worker_version = $WorkerVersion; root = $Root; model_ready = $model.model_ready }
+  }
+  'Status' {
+    $installed = Test-Path -LiteralPath $ConfigPath
+    if (-not $installed) { Write-Json @{ ok = $true; installed = $false; root = $Root }; break }
+    $config = Read-WorkerConfig
+    $model = Get-ModelStatus $config
+    $queued = @(Get-ChildItem -LiteralPath $QueueRoot -Filter '*.json' -ErrorAction SilentlyContinue).Count
+    Write-Json @{ ok = $true; installed = $true; worker_version = $config.worker_version; root = $Root; concurrency = $config.concurrency; queued = $queued; ffmpeg = @{ path = $config.ffmpeg; exists = (Test-Path -LiteralPath $config.ffmpeg) }; ffprobe = @{ path = $config.ffprobe; exists = (Test-Path -LiteralPath $config.ffprobe) }; model_ready = $model.model_ready; model_definitions = $model.model_definitions; model_weights = $model.model_weights }
+  }
+  'Prepare' {
+    $payload = Read-Payload
+    $id = [string]$payload.id
+    $name = [string]$payload.input_name
+    Assert-SafeName $id 'job id'
+    Assert-SafeName $name 'input name'
+    $jobDir = Job-Directory $id
+    @('input', 'output', 'logs') | ForEach-Object { New-Item -ItemType Directory -Force -Path (Join-Path $jobDir $_) | Out-Null }
+    $inputPath = Join-Path (Join-Path $jobDir 'input') $name
+    Set-JobStatus $id @{ state = 'uploading'; input_name = $name; input_path = $inputPath } | Out-Null
+    Write-Json @{ ok = $true; id = $id; input_path = $inputPath }
+  }
+  'Enqueue' {
+    $payload = Read-Payload
+    $id = [string]$payload.id
+    Assert-SafeName $id 'job id'
+    Assert-SafeName ([string]$payload.input_name) 'input name'
+    if ($payload.preset -ne 'seedance-human-1080p') { throw 'Unsupported preset.' }
+    $queuePath = Join-Path $QueueRoot "$id.json"
+    $payload | ConvertTo-Json | Set-Content -LiteralPath "$queuePath.tmp" -Encoding UTF8
+    Move-Item -Force -LiteralPath "$queuePath.tmp" -Destination $queuePath
+    Set-JobStatus $id @{ state = 'queued'; queued_at = (Get-Date).ToUniversalTime().ToString('o'); preset = $payload.preset } | Out-Null
+    Write-Json @{ ok = $true; id = $id; state = 'queued' }
+  }
+  'Run' {
+    $created = $false
+    $mutex = New-Object Threading.Mutex($true, 'Global\TopazLabsCliQueue', [ref]$created)
+    if (-not $created) { exit 0 }
+    try {
+      $config = Read-WorkerConfig
+      while ($true) {
+        $next = Get-ChildItem -LiteralPath $QueueRoot -Filter '*.json' | Sort-Object CreationTimeUtc, Name | Select-Object -First 1
+        if ($null -eq $next) { break }
+        $job = Get-Content -Raw -LiteralPath $next.FullName | ConvertFrom-Json
+        Remove-Item -Force -LiteralPath $next.FullName
+        $cancelPath = Join-Path (Job-Directory ([string]$job.id)) 'cancel.requested'
+        if (Test-Path -LiteralPath $cancelPath) {
+          Set-JobStatus ([string]$job.id) @{ state = 'cancelled'; completed_at = (Get-Date).ToUniversalTime().ToString('o') } | Out-Null
+          continue
+        }
+        try { Invoke-Job $job $config }
+        catch {
+          Set-JobStatus ([string]$job.id) @{ state = 'failed'; completed_at = (Get-Date).ToUniversalTime().ToString('o'); error = $_.Exception.Message } | Out-Null
+        }
+      }
+    } finally {
+      $mutex.ReleaseMutex()
+      $mutex.Dispose()
+    }
+  }
+  'JobStatus' {
+    $payload = Read-Payload
+    $path = Status-Path ([string]$payload.id)
+    if (-not (Test-Path -LiteralPath $path)) { throw 'Job not found.' }
+    [Console]::Out.Write((Get-Content -Raw -LiteralPath $path).Trim())
+  }
+  'ListJobs' {
+    $items = @()
+    Get-ChildItem -LiteralPath $JobsRoot -Directory -ErrorAction SilentlyContinue | ForEach-Object {
+      $path = Join-Path $_.FullName 'status.json'
+      if (Test-Path -LiteralPath $path) {
+        $items += (Get-Content -Raw -LiteralPath $path | ConvertFrom-Json)
+      }
+    }
+    $items = @($items | Sort-Object updated_at -Descending)
+    Write-Json @{ ok = $true; jobs = $items }
+  }
+  'Cancel' {
+    $payload = Read-Payload
+    $id = [string]$payload.id
+    $statusPath = Status-Path $id
+    if (-not (Test-Path -LiteralPath $statusPath)) { throw 'Job not found.' }
+    $status = Get-Content -Raw -LiteralPath $statusPath | ConvertFrom-Json
+    if ($status.state -eq 'running') {
+      New-Item -ItemType File -Force -Path (Join-Path (Job-Directory $id) 'cancel.requested') | Out-Null
+      Set-JobStatus $id @{ cancel_requested = $true } | Out-Null
+      Write-Json @{ ok = $true; id = $id; state = 'running'; cancel_requested = $true; note = 'The current ffmpeg process is not forcibly terminated.' }
+    } elseif ($status.state -eq 'queued' -or $status.state -eq 'uploading') {
+      Remove-Item -Force -ErrorAction SilentlyContinue -LiteralPath (Join-Path $QueueRoot "$id.json")
+      Set-JobStatus $id @{ state = 'cancelled'; completed_at = (Get-Date).ToUniversalTime().ToString('o') } | Out-Null
+      Write-Json @{ ok = $true; id = $id; state = 'cancelled' }
+    } else {
+      Write-Json @{ ok = $true; id = $id; state = $status.state; changed = $false }
+    }
+  }
+}