offwatch 0.5.11 → 0.5.13

package/src/commands/client/plugin.ts

@@ -1,374 +0,0 @@
-import path from "node:path";
-import { Command } from "commander";
-import pc from "picocolors";
-import {
-  addCommonClientOptions,
-  handleCommandError,
-  printOutput,
-  resolveCommandContext,
-  type BaseClientOptions,
-} from "./common.js";
-
-// ---------------------------------------------------------------------------
-// Types mirroring server-side shapes
-// ---------------------------------------------------------------------------
-
-interface PluginRecord {
-  id: string;
-  pluginKey: string;
-  packageName: string;
-  version: string;
-  status: string;
-  displayName?: string;
-  lastError?: string | null;
-  installedAt: string;
-  updatedAt: string;
-}
-
-
-// ---------------------------------------------------------------------------
-// Option types
-// ---------------------------------------------------------------------------
-
-interface PluginListOptions extends BaseClientOptions {
-  status?: string;
-}
-
-interface PluginInstallOptions extends BaseClientOptions {
-  local?: boolean;
-  version?: string;
-}
-
-interface PluginUninstallOptions extends BaseClientOptions {
-  force?: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve a local path argument to an absolute path so the server can find the
- * plugin on disk regardless of where the user ran the CLI.
- */
-function resolvePackageArg(packageArg: string, isLocal: boolean): string {
-  if (!isLocal) return packageArg;
-  // Already absolute
-  if (path.isAbsolute(packageArg)) return packageArg;
-  // Expand leading ~ to home directory
-  if (packageArg.startsWith("~")) {
-    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    return path.resolve(home, packageArg.slice(1).replace(/^[\\/]/, ""));
-  }
-  return path.resolve(process.cwd(), packageArg);
-}
-
-function formatPlugin(p: PluginRecord): string {
-  const statusColor =
-    p.status === "ready"
-      ? pc.green(p.status)
-      : p.status === "error"
-        ? pc.red(p.status)
-        : p.status === "disabled"
-          ? pc.dim(p.status)
-          : pc.yellow(p.status);
-
-  const parts = [
-    `key=${pc.bold(p.pluginKey)}`,
-    `status=${statusColor}`,
-    `version=${p.version}`,
-    `id=${pc.dim(p.id)}`,
-  ];
-
-  if (p.lastError) {
-    parts.push(`error=${pc.red(p.lastError.slice(0, 80))}`);
-  }
-
-  return parts.join("  ");
-}
-
-// ---------------------------------------------------------------------------
-// Command registration
-// ---------------------------------------------------------------------------
-
-export function registerPluginCommands(program: Command): void {
-  const plugin = program.command("plugin").description("Plugin lifecycle management");
-
-  // -------------------------------------------------------------------------
-  // plugin list
-  // -------------------------------------------------------------------------
-  addCommonClientOptions(
-    plugin
-      .command("list")
-      .description("List installed plugins")
-      .option("--status <status>", "Filter by status (ready, error, disabled, installed, upgrade_pending)")
-      .action(async (opts: PluginListOptions) => {
-        try {
-          const ctx = resolveCommandContext(opts);
-          const qs = opts.status ? `?status=${encodeURIComponent(opts.status)}` : "";
-          const plugins = await ctx.api.get<PluginRecord[]>(`/api/plugins${qs}`);
-
-          if (ctx.json) {
-            printOutput(plugins, { json: true });
-            return;
-          }
-
-          const rows = plugins ?? [];
-          if (rows.length === 0) {
-            console.log(pc.dim("No plugins installed."));
-            return;
-          }
-
-          for (const p of rows) {
-            console.log(formatPlugin(p));
-          }
-        } catch (err) {
-          handleCommandError(err);
-        }
-      }),
-  );
-
-  // -------------------------------------------------------------------------
-  // plugin install <package-or-path>
-  // -------------------------------------------------------------------------
-  addCommonClientOptions(
-    plugin
-      .command("install <package>")
-      .description(
-        "Install a plugin from a local path or npm package.\n" +
-          "  Examples:\n" +
-          "    paperclipai plugin install ./my-plugin              # local path\n" +
-          "    paperclipai plugin install @acme/plugin-linear      # npm package\n" +
-          "    paperclipai plugin install @acme/plugin-linear@1.2  # pinned version",
-      )
-      .option("-l, --local", "Treat <package> as a local filesystem path", false)
-      .option("--version <version>", "Specific npm version to install (npm packages only)")
-      .action(async (packageArg: string, opts: PluginInstallOptions) => {
-        try {
-          const ctx = resolveCommandContext(opts);
-
-          // Auto-detect local paths: starts with . or / or ~ or is an absolute path
-          const isLocal =
-            opts.local ||
-            packageArg.startsWith("./") ||
-            packageArg.startsWith("../") ||
-            packageArg.startsWith("/") ||
-            packageArg.startsWith("~");
-
-          const resolvedPackage = resolvePackageArg(packageArg, isLocal);
-
-          if (!ctx.json) {
-            console.log(
-              pc.dim(
-                isLocal
-                  ? `Installing plugin from local path: ${resolvedPackage}`
-                  : `Installing plugin: ${resolvedPackage}${opts.version ? `@${opts.version}` : ""}`,
-              ),
-            );
-          }
-
-          const installedPlugin = await ctx.api.post<PluginRecord>("/api/plugins/install", {
-            packageName: resolvedPackage,
-            version: opts.version,
-            isLocalPath: isLocal,
-          });
-
-          if (ctx.json) {
-            printOutput(installedPlugin, { json: true });
-            return;
-          }
-
-          if (!installedPlugin) {
-            console.log(pc.dim("Install returned no plugin record."));
-            return;
-          }
-
-          console.log(
-            pc.green(
-              `✓ Installed ${pc.bold(installedPlugin.pluginKey)} v${installedPlugin.version} (${installedPlugin.status})`,
-            ),
-          );
-
-          if (installedPlugin.lastError) {
-            console.log(pc.red(`  Warning: ${installedPlugin.lastError}`));
-          }
-        } catch (err) {
-          handleCommandError(err);
-        }
-      }),
-  );
-
-  // -------------------------------------------------------------------------
-  // plugin uninstall <plugin-key-or-id>
-  // -------------------------------------------------------------------------
-  addCommonClientOptions(
-    plugin
-      .command("uninstall <pluginKey>")
-      .description(
-        "Uninstall a plugin by its plugin key or database ID.\n" +
-          "  Use --force to hard-purge all state and config.",
-      )
-      .option("--force", "Purge all plugin state and config (hard delete)", false)
-      .action(async (pluginKey: string, opts: PluginUninstallOptions) => {
-        try {
-          const ctx = resolveCommandContext(opts);
-          const purge = opts.force === true;
-          const qs = purge ? "?purge=true" : "";
-
-          if (!ctx.json) {
-            console.log(
-              pc.dim(
-                purge
-                  ? `Uninstalling and purging plugin: ${pluginKey}`
-                  : `Uninstalling plugin: ${pluginKey}`,
-              ),
-            );
-          }
-
-          const result = await ctx.api.delete<PluginRecord | null>(
-            `/api/plugins/${encodeURIComponent(pluginKey)}${qs}`,
-          );
-
-          if (ctx.json) {
-            printOutput(result, { json: true });
-            return;
-          }
-
-          console.log(pc.green(`✓ Uninstalled ${pc.bold(pluginKey)}${purge ? " (purged)" : ""}`));
-        } catch (err) {
-          handleCommandError(err);
-        }
-      }),
-  );
-
-  // -------------------------------------------------------------------------
-  // plugin enable <plugin-key-or-id>
-  // -------------------------------------------------------------------------
-  addCommonClientOptions(
-    plugin
-      .command("enable <pluginKey>")
-      .description("Enable a disabled or errored plugin")
-      .action(async (pluginKey: string, opts: BaseClientOptions) => {
-        try {
-          const ctx = resolveCommandContext(opts);
-          const result = await ctx.api.post<PluginRecord>(
-            `/api/plugins/${encodeURIComponent(pluginKey)}/enable`,
-          );
-
-          if (ctx.json) {
-            printOutput(result, { json: true });
-            return;
-          }
-
-          console.log(pc.green(`✓ Enabled ${pc.bold(pluginKey)} — status: ${result?.status ?? "unknown"}`));
-        } catch (err) {
-          handleCommandError(err);
-        }
-      }),
-  );
-
-  // -------------------------------------------------------------------------
-  // plugin disable <plugin-key-or-id>
-  // -------------------------------------------------------------------------
-  addCommonClientOptions(
-    plugin
-      .command("disable <pluginKey>")
-      .description("Disable a running plugin without uninstalling it")
-      .action(async (pluginKey: string, opts: BaseClientOptions) => {
-        try {
-          const ctx = resolveCommandContext(opts);
-          const result = await ctx.api.post<PluginRecord>(
-            `/api/plugins/${encodeURIComponent(pluginKey)}/disable`,
-          );
-
-          if (ctx.json) {
-            printOutput(result, { json: true });
-            return;
-          }
-
-          console.log(pc.dim(`Disabled ${pc.bold(pluginKey)} — status: ${result?.status ?? "unknown"}`));
-        } catch (err) {
-          handleCommandError(err);
-        }
-      }),
-  );
-
-  // -------------------------------------------------------------------------
-  // plugin inspect <plugin-key-or-id>
-  // -------------------------------------------------------------------------
-  addCommonClientOptions(
-    plugin
-      .command("inspect <pluginKey>")
-      .description("Show full details for an installed plugin")
-      .action(async (pluginKey: string, opts: BaseClientOptions) => {
-        try {
-          const ctx = resolveCommandContext(opts);
-          const result = await ctx.api.get<PluginRecord>(
-            `/api/plugins/${encodeURIComponent(pluginKey)}`,
-          );
-
-          if (ctx.json) {
-            printOutput(result, { json: true });
-            return;
-          }
-
-          if (!result) {
-            console.log(pc.red(`Plugin not found: ${pluginKey}`));
-            process.exit(1);
-          }
-
-          console.log(formatPlugin(result));
-          if (result.lastError) {
-            console.log(`\n${pc.red("Last error:")}\n${result.lastError}`);
-          }
-        } catch (err) {
-          handleCommandError(err);
-        }
-      }),
-  );
-
-  // -------------------------------------------------------------------------
-  // plugin examples
-  // -------------------------------------------------------------------------
-  addCommonClientOptions(
-    plugin
-      .command("examples")
-      .description("List bundled example plugins available for local install")
-      .action(async (opts: BaseClientOptions) => {
-        try {
-          const ctx = resolveCommandContext(opts);
-          const examples = await ctx.api.get<
-            Array<{
-              packageName: string;
-              pluginKey: string;
-              displayName: string;
-              description: string;
-              localPath: string;
-              tag: string;
-            }>
-          >("/api/plugins/examples");
-
-          if (ctx.json) {
-            printOutput(examples, { json: true });
-            return;
-          }
-
-          const rows = examples ?? [];
-          if (rows.length === 0) {
-            console.log(pc.dim("No bundled examples available."));
-            return;
-          }
-
-          for (const ex of rows) {
-            console.log(
-              `${pc.bold(ex.displayName)}  ${pc.dim(ex.pluginKey)}\n` +
-                `  ${ex.description}\n` +
-                `  ${pc.cyan(`paperclipai plugin install ${ex.localPath}`)}`,
-            );
-          }
-        } catch (err) {
-          handleCommandError(err);
-        }
-      }),
-  );
-}

package/src/commands/client/zip.ts

@@ -1,129 +0,0 @@
-import { inflateRawSync } from "node:zlib";
-import path from "node:path";
-import type { CompanyPortabilityFileEntry } from "@paperclipai/shared";
-
-const textDecoder = new TextDecoder();
-
-export const binaryContentTypeByExtension: Record<string, string> = {
-  ".gif": "image/gif",
-  ".jpeg": "image/jpeg",
-  ".jpg": "image/jpeg",
-  ".png": "image/png",
-  ".svg": "image/svg+xml",
-  ".webp": "image/webp",
-};
-
-function normalizeArchivePath(pathValue: string) {
-  return pathValue
-    .replace(/\\/g, "/")
-    .split("/")
-    .filter(Boolean)
-    .join("/");
-}
-
-function readUint16(source: Uint8Array, offset: number) {
-  return source[offset]! | (source[offset + 1]! << 8);
-}
-
-function readUint32(source: Uint8Array, offset: number) {
-  return (
-    source[offset]! |
-    (source[offset + 1]! << 8) |
-    (source[offset + 2]! << 16) |
-    (source[offset + 3]! << 24)
-  ) >>> 0;
-}
-
-function sharedArchiveRoot(paths: string[]) {
-  if (paths.length === 0) return null;
-  const firstSegments = paths
-    .map((entry) => normalizeArchivePath(entry).split("/").filter(Boolean))
-    .filter((parts) => parts.length > 0);
-  if (firstSegments.length === 0) return null;
-  const candidate = firstSegments[0]![0]!;
-  return firstSegments.every((parts) => parts.length > 1 && parts[0] === candidate)
-    ? candidate
-    : null;
-}
-
-function bytesToPortableFileEntry(pathValue: string, bytes: Uint8Array): CompanyPortabilityFileEntry {
-  const contentType = binaryContentTypeByExtension[path.extname(pathValue).toLowerCase()];
-  if (!contentType) return textDecoder.decode(bytes);
-  return {
-    encoding: "base64",
-    data: Buffer.from(bytes).toString("base64"),
-    contentType,
-  };
-}
-
-async function inflateZipEntry(compressionMethod: number, bytes: Uint8Array) {
-  if (compressionMethod === 0) return bytes;
-  if (compressionMethod !== 8) {
-    throw new Error("Unsupported zip archive: only STORE and DEFLATE entries are supported.");
-  }
-  return new Uint8Array(inflateRawSync(bytes));
-}
-
-export async function readZipArchive(source: ArrayBuffer | Uint8Array): Promise<{
-  rootPath: string | null;
-  files: Record<string, CompanyPortabilityFileEntry>;
-}> {
-  const bytes = source instanceof Uint8Array ? source : new Uint8Array(source);
-  const entries: Array<{ path: string; body: CompanyPortabilityFileEntry }> = [];
-  let offset = 0;
-
-  while (offset + 4 <= bytes.length) {
-    const signature = readUint32(bytes, offset);
-    if (signature === 0x02014b50 || signature === 0x06054b50) break;
-    if (signature !== 0x04034b50) {
-      throw new Error("Invalid zip archive: unsupported local file header.");
-    }
-
-    if (offset + 30 > bytes.length) {
-      throw new Error("Invalid zip archive: truncated local file header.");
-    }
-
-    const generalPurposeFlag = readUint16(bytes, offset + 6);
-    const compressionMethod = readUint16(bytes, offset + 8);
-    const compressedSize = readUint32(bytes, offset + 18);
-    const fileNameLength = readUint16(bytes, offset + 26);
-    const extraFieldLength = readUint16(bytes, offset + 28);
-
-    if ((generalPurposeFlag & 0x0008) !== 0) {
-      throw new Error("Unsupported zip archive: data descriptors are not supported.");
-    }
-
-    const nameOffset = offset + 30;
-    const bodyOffset = nameOffset + fileNameLength + extraFieldLength;
-    const bodyEnd = bodyOffset + compressedSize;
-    if (bodyEnd > bytes.length) {
-      throw new Error("Invalid zip archive: truncated file contents.");
-    }
-
-    const rawArchivePath = textDecoder.decode(bytes.slice(nameOffset, nameOffset + fileNameLength));
-    const archivePath = normalizeArchivePath(rawArchivePath);
-    const isDirectoryEntry = /\/$/.test(rawArchivePath.replace(/\\/g, "/"));
-    if (archivePath && !isDirectoryEntry) {
-      const entryBytes = await inflateZipEntry(compressionMethod, bytes.slice(bodyOffset, bodyEnd));
-      entries.push({
-        path: archivePath,
-        body: bytesToPortableFileEntry(archivePath, entryBytes),
-      });
-    }
-
-    offset = bodyEnd;
-  }
-
-  const rootPath = sharedArchiveRoot(entries.map((entry) => entry.path));
-  const files: Record<string, CompanyPortabilityFileEntry> = {};
-  for (const entry of entries) {
-    const normalizedPath =
-      rootPath && entry.path.startsWith(`${rootPath}/`)
-        ? entry.path.slice(rootPath.length + 1)
-        : entry.path;
-    if (!normalizedPath) continue;
-    files[normalizedPath] = entry.body;
-  }
-
-  return { rootPath, files };
-}

package/src/commands/configure.ts

@@ -1,201 +0,0 @@
-import * as p from "@clack/prompts";
-import pc from "picocolors";
-import { readConfig, writeConfig, configExists, resolveConfigPath } from "../config/store.js";
-import type { PaperclipConfig } from "../config/schema.js";
-import { ensureLocalSecretsKeyFile } from "../config/secrets-key.js";
-import { promptDatabase } from "../prompts/database.js";
-import { promptLlm } from "../prompts/llm.js";
-import { promptLogging } from "../prompts/logging.js";
-import { defaultSecretsConfig, promptSecrets } from "../prompts/secrets.js";
-import { defaultStorageConfig, promptStorage } from "../prompts/storage.js";
-import { promptServer } from "../prompts/server.js";
-import {
-  resolveDefaultBackupDir,
-  resolveDefaultEmbeddedPostgresDir,
-  resolveDefaultLogsDir,
-  resolvePaperclipInstanceId,
-} from "../config/home.js";
-import { printPaperclipCliBanner } from "../utils/banner.js";
-
-type Section = "llm" | "database" | "logging" | "server" | "storage" | "secrets";
-
-const SECTION_LABELS: Record<Section, string> = {
-  llm: "LLM Provider",
-  database: "Database",
-  logging: "Logging",
-  server: "Server",
-  storage: "Storage",
-  secrets: "Secrets",
-};
-
-function defaultConfig(): PaperclipConfig {
-  const instanceId = resolvePaperclipInstanceId();
-  return {
-    $meta: {
-      version: 1,
-      updatedAt: new Date().toISOString(),
-      source: "configure",
-    },
-    database: {
-      mode: "embedded-postgres",
-      embeddedPostgresDataDir: resolveDefaultEmbeddedPostgresDir(instanceId),
-      embeddedPostgresPort: 54329,
-      backup: {
-        enabled: true,
-        intervalMinutes: 60,
-        retentionDays: 30,
-        dir: resolveDefaultBackupDir(instanceId),
-      },
-    },
-    logging: {
-      mode: "file",
-      logDir: resolveDefaultLogsDir(instanceId),
-    },
-    server: {
-      deploymentMode: "local_trusted",
-      exposure: "private",
-      bind: "loopback",
-      host: "127.0.0.1",
-      port: 3100,
-      allowedHostnames: [],
-      serveUi: true,
-    },
-    auth: {
-      baseUrlMode: "auto",
-      disableSignUp: false,
-    },
-    telemetry: {
-      enabled: true,
-    },
-    storage: defaultStorageConfig(),
-    secrets: defaultSecretsConfig(),
-  };
-}
-
-export async function configure(opts: {
-  config?: string;
-  section?: string;
-}): Promise<void> {
-  printPaperclipCliBanner();
-  p.intro(pc.bgCyan(pc.black(" paperclip configure ")));
-  const configPath = resolveConfigPath(opts.config);
-
-  if (!configExists(opts.config)) {
-    p.log.error("No config file found. Run `paperclipai onboard` first.");
-    p.outro("");
-    return;
-  }
-
-  let config: PaperclipConfig;
-  try {
-    config = readConfig(opts.config) ?? defaultConfig();
-  } catch (err) {
-    p.log.message(
-      pc.yellow(
-        `Existing config is invalid. Loading defaults so you can repair it now.\n${err instanceof Error ? err.message : String(err)}`,
-      ),
-    );
-    config = defaultConfig();
-  }
-
-  let section: Section | undefined = opts.section as Section | undefined;
-
-  if (section && !SECTION_LABELS[section]) {
-    p.log.error(`Unknown section: ${section}. Choose from: ${Object.keys(SECTION_LABELS).join(", ")}`);
-    p.outro("");
-    return;
-  }
-
-  // Section selection loop
-  let continueLoop = true;
-  while (continueLoop) {
-    if (!section) {
-      const choice = await p.select({
-        message: "Which section do you want to configure?",
-        options: Object.entries(SECTION_LABELS).map(([value, label]) => ({
-          value: value as Section,
-          label,
-        })),
-      });
-
-      if (p.isCancel(choice)) {
-        p.cancel("Configuration cancelled.");
-        return;
-      }
-
-      section = choice;
-    }
-
-    p.log.step(pc.bold(SECTION_LABELS[section]));
-
-    switch (section) {
-      case "database":
-        config.database = await promptDatabase(config.database);
-        break;
-      case "llm": {
-        const llm = await promptLlm();
-        if (llm) {
-          config.llm = llm;
-        } else {
-          delete config.llm;
-        }
-        break;
-      }
-      case "logging":
-        config.logging = await promptLogging();
-        break;
-      case "server":
-        {
-          const { server, auth } = await promptServer({
-            currentServer: config.server,
-            currentAuth: config.auth,
-          });
-          config.server = server;
-          config.auth = auth;
-        }
-        break;
-      case "storage":
-        config.storage = await promptStorage(config.storage);
-        break;
-      case "secrets":
-        config.secrets = await promptSecrets(config.secrets);
-        {
-          const keyResult = ensureLocalSecretsKeyFile(config, configPath);
-          if (keyResult.status === "created") {
-            p.log.success(`Created local secrets key file at ${pc.dim(keyResult.path)}`);
-          } else if (keyResult.status === "existing") {
-            p.log.message(pc.dim(`Using existing local secrets key file at ${keyResult.path}`));
-          } else if (keyResult.status === "skipped_provider") {
-            p.log.message(pc.dim("Skipping local key file management for non-local provider"));
-          } else {
-            p.log.message(pc.dim("Skipping local key file management because PAPERCLIP_SECRETS_MASTER_KEY is set"));
-          }
-        }
-        break;
-    }
-
-    config.$meta.updatedAt = new Date().toISOString();
-    config.$meta.source = "configure";
-
-    writeConfig(config, opts.config);
-    p.log.success(`${SECTION_LABELS[section]} configuration updated.`);
-
-    // If section was provided via CLI flag, don't loop
-    if (opts.section) {
-      continueLoop = false;
-    } else {
-      const another = await p.confirm({
-        message: "Configure another section?",
-        initialValue: false,
-      });
-
-      if (p.isCancel(another) || !another) {
-        continueLoop = false;
-      } else {
-        section = undefined; // Reset to show picker again
-      }
-    }
-  }
-
-  p.outro("Configuration saved.");
-}