quoxcli 0.0.0-stage → 0.3.1

package/lib/commands/prompt.js

@@ -0,0 +1,350 @@
+/**
+ * Prompt commands: user-owned prompts library (CRUD + versions + import/export)
+ *
+ * quox prompt list|get|create|update|delete|versions|restore|export|import
+ *
+ * Backend: services/auth/routes/prompts.js, mounted at plain `/api/prompts`
+ * (NOT org-scoped in the URL — server.js:726). Every operation still requires
+ * an org_id: GETs take it as a query param, writes take it as a body field.
+ */
+
+import { readFileSync } from 'node:fs';
+import { formatOutput, formatDetail, printSuccess, printWarning, printInfo } from '../core/output.js';
+import { resolveOrgId } from './helpers.js';
+import { resolveEndpoint } from '../api/endpoints.js';
+import { confirmDestructive } from '../core/confirm.js';
+
+/** Parse a stored JSON-string field (tags/variables/deploy_targets) back to an array/object. */
+function parseJsonField(value) {
+  if (Array.isArray(value) || (value !== null && typeof value === 'object')) return value;
+  if (typeof value !== 'string' || value.trim() === '') return [];
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+/**
+ * Format a created_at/updated_at value for display. The value may be an
+ * epoch-millis number, an all-digits epoch-millis string, or an ISO string,
+ * depending on the path it came through. Falsy values pass through as-is
+ * rather than rendering "Invalid Date".
+ */
+function formatTimestamp(value) {
+  if (!value) return value;
+  const isEpochMillis = (typeof value === 'number' && Number.isFinite(value))
+    || (typeof value === 'string' && /^\d+$/.test(value));
+  const date = isEpochMillis ? new Date(Number(value)) : new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toISOString().replace('T', ' ').replace(/\.\d+Z$/, ' UTC');
+}
+
+/**
+ * Extract `{{identifier}}` template variables from prompt body text, in
+ * order of first appearance, deduped. Conservative identifier pattern
+ * (`[A-Za-z_][A-Za-z0-9_]*`) so arbitrary template expressions (helpers,
+ * filters, nested paths) aren't misparsed as variable names.
+ */
+function extractVariables(body) {
+  if (typeof body !== 'string' || body === '') return [];
+  const seen = new Set();
+  const variables = [];
+  const re = /\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
+  let match;
+  while ((match = re.exec(body)) !== null) {
+    if (!seen.has(match[1])) {
+      seen.add(match[1]);
+      variables.push(match[1]);
+    }
+  }
+  return variables;
+}
+
+function normalizePrompt(p) {
+  if (!p) return p;
+  return {
+    ...p,
+    tags: parseJsonField(p.tags),
+    variables: parseJsonField(p.variables),
+    deploy_targets: parseJsonField(p.deploy_targets),
+    created_at: formatTimestamp(p.created_at),
+    updated_at: formatTimestamp(p.updated_at),
+  };
+}
+
+/** Resolve prompt content from --content or --file. Throws if neither given. */
+function resolveContent(options) {
+  if (options.file) {
+    return readFileSync(options.file, 'utf-8');
+  }
+  if (options.content !== undefined) {
+    return options.content;
+  }
+  return undefined;
+}
+
+export function registerPromptCommands(program, ctx) {
+  const { client, auth } = ctx;
+
+  const prompt = program
+    .command('prompt')
+    .description('Manage the user-owned prompts library');
+
+  // ── prompt list ─────────────────────────────────────────────────────────────
+
+  prompt
+    .command('list')
+    .description('List prompts (own + org-visible)')
+    .option('--search <text>', 'substring search on name/body')
+    .option('--tags <tags>', 'comma-separated tag filter (match any)')
+    .action(async (options) => {
+      auth.requireAuth();
+      const orgId = resolveOrgId(auth, program);
+      const query = { org_id: orgId };
+      if (options.search) query.q = options.search;
+      if (options.tags) query.tags = options.tags;
+
+      const data = await client.get(resolveEndpoint('prompts.list').path, {
+        service: resolveEndpoint('prompts.list').service,
+        query,
+      });
+      const prompts = (data.prompts || data || []).map(normalizePrompt);
+
+      formatOutput({
+        columns: ['id', 'name', 'category', 'visibility', 'tags', 'updated_at'],
+        headers: ['ID', 'Name', 'Category', 'Visibility', 'Tags', 'Updated'],
+        rows: prompts.map(p => ({
+          ...p,
+          tags: Array.isArray(p.tags) ? p.tags.join(', ') : p.tags,
+        })),
+      }, { format: program.opts().output, emptyMessage: 'No prompts found.' });
+    });
+
+  // ── prompt get ──────────────────────────────────────────────────────────────
+
+  prompt
+    .command('get')
+    .description('Show prompt details')
+    .argument('<id>', 'prompt ID')
+    .action(async (id) => {
+      auth.requireAuth();
+      const orgId = resolveOrgId(auth, program);
+      const data = await client.get(resolveEndpoint('prompts.get', { id }).path, {
+        service: resolveEndpoint('prompts.get', { id }).service,
+        query: { org_id: orgId },
+      });
+      const p = normalizePrompt(data.prompt || data);
+
+      formatDetail(p, {
+        format: program.opts().output,
+        title: `Prompt: ${p.name || id}`,
+        fields: ['id', 'name', 'description', 'category', 'visibility', 'tags', 'body', 'variables', 'deploy_targets', 'created_at', 'updated_at'],
+        labels: {
+          id: 'ID', name: 'Name', description: 'Description', category: 'Category',
+          visibility: 'Visibility', tags: 'Tags', body: 'Body', variables: 'Variables',
+          deploy_targets: 'Deploy Targets', created_at: 'Created', updated_at: 'Updated',
+        },
+      });
+    });
+
+  // ── prompt create ───────────────────────────────────────────────────────────
+
+  prompt
+    .command('create')
+    .description('Create a prompt')
+    .requiredOption('--name <name>', 'prompt name')
+    .option('--content <text>', 'prompt body text')
+    .option('--file <path>', 'read prompt body from a file (overrides --content)')
+    .option('--description <text>', 'description')
+    .option('--tags <tags>', 'comma-separated tags')
+    .option('--category <category>', 'category')
+    .option('--visibility <vis>', 'private|org', 'private')
+    .action(async (options) => {
+      auth.requireAuth();
+      const orgId = resolveOrgId(auth, program);
+
+      const body = resolveContent(options);
+      if (body === undefined || body.trim() === '') {
+        throw new Error('Prompt content is required. Use --content <text> or --file <path>.');
+      }
+
+      const payload = { org_id: orgId, name: options.name, body };
+      if (options.description) payload.description = options.description;
+      if (options.tags) payload.tags = options.tags.split(',').map(t => t.trim()).filter(Boolean);
+      if (options.category) payload.category = options.category;
+      if (options.visibility) payload.visibility = options.visibility;
+      // fleet #398: nothing extracted {{var}} tokens from the body, so
+      // `variables` was always stored as []. Only fill it in when the
+      // caller didn't explicitly pass one, and only when the body actually
+      // contains variables (keeps the payload identical to before for
+      // variable-less prompts).
+      const createdVariables = extractVariables(body);
+      if (payload.variables === undefined && createdVariables.length > 0) payload.variables = createdVariables;
+
+      const data = await client.post(resolveEndpoint('prompts.create').path, {
+        service: resolveEndpoint('prompts.create').service,
+        body: payload,
+      });
+      printSuccess(`Prompt "${options.name}" created.`);
+      formatDetail(normalizePrompt(data.prompt || data), { format: program.opts().output });
+    });
+
+  // ── prompt update ───────────────────────────────────────────────────────────
+
+  prompt
+    .command('update')
+    .description('Update a prompt (bumps version)')
+    .argument('<id>', 'prompt ID')
+    .option('--name <name>', 'new name')
+    .option('--content <text>', 'new body text')
+    .option('--file <path>', 'read new body from a file (overrides --content)')
+    .option('--description <text>', 'new description')
+    .option('--tags <tags>', 'new tags (comma-separated)')
+    .option('--category <category>', 'new category')
+    .option('--visibility <vis>', 'private|org')
+    .action(async (id, options) => {
+      auth.requireAuth();
+      const orgId = resolveOrgId(auth, program);
+
+      const newBody = resolveContent(options);
+      const payload = { org_id: orgId };
+      if (options.name) payload.name = options.name;
+      if (newBody !== undefined) payload.body = newBody;
+      if (options.description !== undefined) payload.description = options.description;
+      if (options.tags) payload.tags = options.tags.split(',').map(t => t.trim()).filter(Boolean);
+      if (options.category) payload.category = options.category;
+      if (options.visibility) payload.visibility = options.visibility;
+      // Re-extract {{var}} tokens whenever the body changes, so stale
+      // variables from the old body don't linger. Only when the caller
+      // didn't explicitly pass one.
+      if (newBody !== undefined && payload.variables === undefined) {
+        payload.variables = extractVariables(newBody);
+      }
+
+      if (Object.keys(payload).length === 1) {
+        throw new Error('Specify at least one field to update (--name, --content/--file, --description, --tags, --category, --visibility).');
+      }
+
+      const data = await client.patch(resolveEndpoint('prompts.update', { id }).path, {
+        service: resolveEndpoint('prompts.update', { id }).service,
+        body: payload,
+      });
+      printSuccess('Prompt updated.');
+      formatDetail(normalizePrompt(data.prompt || data), { format: program.opts().output });
+    });
+
+  // ── prompt delete ───────────────────────────────────────────────────────────
+
+  prompt
+    .command('delete')
+    .description('Delete a prompt (soft-delete)')
+    .argument('<id>', 'prompt ID')
+    .option('--force', 'skip confirmation')
+    .action(async (id, options) => {
+      auth.requireAuth();
+      const orgId = resolveOrgId(auth, program);
+
+      const confirmed = await confirmDestructive(program, options, `Delete prompt ${id}? This cannot be undone.`);
+      if (!confirmed) {
+        printInfo('Cancelled.');
+        return;
+      }
+
+      // NOTE: org_id MUST be sent in the body, not the query string. The
+      // handler's `req.body || req.query` fallback (prompts.js:431) never
+      // reaches req.query because express.json() leaves req.body as a
+      // truthy `{}` even on a request with no JSON body.
+      await client.delete(resolveEndpoint('prompts.delete', { id }).path, {
+        service: resolveEndpoint('prompts.delete', { id }).service,
+        body: { org_id: orgId },
+      });
+      printSuccess('Prompt deleted.');
+    });
+
+  // ── prompt versions ─────────────────────────────────────────────────────────
+
+  prompt
+    .command('versions')
+    .description('Show version history for a prompt')
+    .argument('<id>', 'prompt ID')
+    .action(async (id) => {
+      auth.requireAuth();
+      const orgId = resolveOrgId(auth, program);
+      const data = await client.get(resolveEndpoint('prompts.versions', { id }).path, {
+        service: resolveEndpoint('prompts.versions', { id }).service,
+        query: { org_id: orgId },
+      });
+      const versions = data.versions || data || [];
+
+      formatOutput({
+        columns: ['version', 'name', 'created_at', 'created_by'],
+        headers: ['Version', 'Name', 'Created', 'By'],
+        rows: versions,
+      }, { format: program.opts().output, emptyMessage: 'No version history found.' });
+    });
+
+  // ── prompt restore ──────────────────────────────────────────────────────────
+
+  prompt
+    .command('restore')
+    .description('Restore a prompt to a previous version')
+    .argument('<id>', 'prompt ID')
+    .argument('<version>', 'version number to restore')
+    .action(async (id, version) => {
+      auth.requireAuth();
+      const orgId = resolveOrgId(auth, program);
+      const data = await client.post(resolveEndpoint('prompts.restore', { id, version }).path, {
+        service: resolveEndpoint('prompts.restore', { id, version }).service,
+        body: { org_id: orgId },
+      });
+      printSuccess(`Prompt restored from version ${version}.`);
+      formatDetail(normalizePrompt(data.prompt || data), { format: program.opts().output });
+    });
+
+  // ── prompt export ───────────────────────────────────────────────────────────
+
+  prompt
+    .command('export')
+    .description('Export all of the caller\'s prompts as JSON')
+    .action(async () => {
+      auth.requireAuth();
+      const orgId = resolveOrgId(auth, program);
+      const data = await client.get(resolveEndpoint('prompts.export').path, {
+        service: resolveEndpoint('prompts.export').service,
+        query: { org_id: orgId },
+      });
+      console.log(JSON.stringify(data, null, 2));
+    });
+
+  // ── prompt import ───────────────────────────────────────────────────────────
+
+  prompt
+    .command('import')
+    .description('Bulk-import prompts from a JSON file (as produced by `quox prompt export`)')
+    .argument('<file>', 'path to a JSON file with an array of prompts or { prompts: [...] }')
+    .action(async (file) => {
+      auth.requireAuth();
+      const orgId = resolveOrgId(auth, program);
+
+      let parsed;
+      try {
+        parsed = JSON.parse(readFileSync(file, 'utf-8'));
+      } catch (err) {
+        throw new Error(`Could not read/parse ${file}: ${err.message}`);
+      }
+      const prompts = Array.isArray(parsed) ? parsed : (parsed.prompts || []);
+      if (!Array.isArray(prompts) || prompts.length === 0) {
+        throw new Error(`No prompts found in ${file}. Expected an array or { "prompts": [...] }.`);
+      }
+
+      const data = await client.post(resolveEndpoint('prompts.import').path, {
+        service: resolveEndpoint('prompts.import').service,
+        body: { org_id: orgId, prompts },
+      });
+      printSuccess(`Imported ${data.imported ?? 0} prompt(s).`);
+      if ((data.imported ?? 0) < prompts.length) {
+        printWarning(`${prompts.length - (data.imported ?? 0)} prompt(s) were skipped (missing name/body).`);
+      }
+    });
+}

package/lib/commands/provider.js

@@ -0,0 +1,159 @@
+/**
+ * quox provider list | connect <kind> | test [<kind>]  (quox#1281, CLI verb first)
+ *
+ * The SAME backend calls as the TUI's /connect: cli/lib/quoxon/connect.js flows (connectFlow, connectOllamaFlow,
+ * connectCompatFlow, connectionLines) over cli/lib/quoxon/api.js createApi (the auth vault create/update with
+ * confirm_private_origin, the server-side key test and Ollama / OpenAI-compatible probes, capabilities, consent).
+ * Nothing here talks to the backend on its own, so the TUI and the CLI cannot drift. The vault routes audit every
+ * write server side (integration.private_origin for a private address), org-scoped by the caller's session.
+ *
+ * Secrets: a key is never an argv flag or argument. It arrives on stdin (--key-from-stdin) or from a hidden prompt,
+ * is sent once to the server test and the vault, and is never printed (connectFlow scrubs it from any message).
+ */
+import { formatDetail, printInfo } from '../core/output.js';
+import { resolveOrgId } from './helpers.js';
+import { resolveEndpoint } from '../api/endpoints.js';
+import { createApi, isInteractiveHuman } from '../quoxon/api.js';
+import { PROVIDERS, providerFor, looksLikeKey, connectionLines, connectFlow, connectOllamaFlow, connectCompatFlow } from '../quoxon/connect.js';
+import { needsConsent, consentCovers, connectConsentNote, providerLabel } from '../quoxon/consent.js';
+import { readStdin } from '../quoxon/print.js';
+
+const KINDS = Object.keys(PROVIDERS);
+const SAFE_ROW = ['id', 'integration_type', 'label', 'is_default', 'test_status', 'last_tested_at', 'created_at'];
+const CONTAINER_NOTE = 'Quox runs in containers: 127.0.0.1 or localhost means the Quox container, not your machine. Use the host\'s LAN IP, e.g. http://192.0.2.10:11434';
+
+function defaultIO() {
+  return {
+    isTTY: () => isInteractiveHuman(),
+    readStdin: () => readStdin(),
+    promptSecret: async (message) => {
+      const { default: inquirer } = await import('inquirer');
+      const a = await inquirer.prompt([{ type: 'password', name: 'v', message, mask: '*' }]);
+      return a.v;
+    },
+    confirm: async (message) => {
+      const { default: inquirer } = await import('inquirer');
+      const a = await inquirer.prompt([{ type: 'confirm', name: 'v', message, default: false }]);
+      return Boolean(a.v);
+    },
+  };
+}
+
+const say = (lines) => { for (const [t] of lines || []) printInfo(t); };
+
+export function registerProviderCommands(program, ctx) {
+  const { client, auth, config } = ctx;
+  const io = ctx.providerIO || defaultIO();
+  const api = () => (ctx.makeApi ? ctx.makeApi() : createApi({ client, config, auth }));
+
+  const provider = program
+    .command('provider')
+    .description('Connect the AI providers your org uses (the same as /connect in the Quox terminal)');
+
+  // ── provider list ──────────────────────────────────────────────────────────
+  provider
+    .command('list')
+    .description('Show which AI providers this org can use, and how each is connected')
+    .action(async () => {
+      auth.requireAuth();
+      const a = api();
+      const [vault, caps] = await Promise.all([a.connections(), a.capabilities ? a.capabilities() : null]);
+      if (program.opts().output === 'json') {
+        const rows = vault?.ok ? vault.rows.map((r) => Object.fromEntries(SAFE_ROW.filter((k) => r[k] !== undefined).map((k) => [k, r[k]]))) : null;
+        formatDetail({ connections: rows, ...(vault?.ok ? {} : { error: vault?.error || 'vault not readable' }), capabilities: caps?.ok ? caps.capabilities : null }, { format: 'json' });
+        return;
+      }
+      say(connectionLines(vault, caps));
+    });
+
+  // ── provider connect ───────────────────────────────────────────────────────
+  const readKey = async (p, opts) => {
+    if (opts.keyFromStdin) return String(await io.readStdin() || '').replace(/\r?\n$/, '').trim();
+    if (io.isTTY()) return String(await io.promptSecret(`${p.name} key (hidden, never shown or stored on this machine):`) || '').trim();
+    throw new Error(`No key given. Pipe it in with --key-from-stdin (for example: quox provider connect ${p.id} --key-from-stdin < keyfile), or run this in a terminal to be asked. A key is never taken as an argument.`);
+  };
+  const consentAfter = async (type) => {
+    const a = api();
+    if (!needsConsent(type) || !a.consentStatus) return;
+    let rec = null; try { rec = await a.consentStatus(); } catch { rec = null; }
+    if (consentCovers(rec, type)) return;
+    // --yes never grants consent: it is this person's own OK to send their conversations to a third party
+    if (!io.isTTY() || !a.grantConsent) { printInfo(connectConsentNote(type)); return; }
+    const yes = await io.confirm(`Allow Quox to send your conversations to ${providerLabel(type)}? Your messages and tool results go to ${providerLabel(type)}, a third party, when it answers. Nothing is sent until you say yes.`);
+    if (!yes) { printInfo(`Left off: nothing goes to ${providerLabel(type)} until you say so. ${connectConsentNote(type)}`); return; }
+    try { await a.grantConsent(type); printInfo(`✔ Your OK is recorded: ${providerLabel(type)} can now answer. Withdraw it any time: quox consent list.`); }
+    catch (e) { printInfo(`Quox could not record your OK (${e?.message || e}). Try: quox consent grant ${type}`); }
+  };
+
+  provider
+    .command('connect')
+    .description('Connect an AI provider for this org: a keyed provider (openai, anthropic, groq...) takes its key on stdin or a hidden prompt; a self-hosted one (ollama, lmstudio, vllm, custom) takes a URL')
+    .argument('<kind>', `provider: ${KINDS.join(', ')}`)
+    .argument('[url]', 'server URL for ollama / lmstudio / vllm / custom (same as --url)')
+    .option('--url <url>', `server URL for a self-hosted provider. ${CONTAINER_NOTE}`)
+    .option('--model <model>', 'default model to use on that server')
+    .option('--key-from-stdin', 'read the API key from stdin (never pass a key as an argument)')
+    .option('--yes', 'confirm connecting to an address on your private network (the server still checks it and audits the decision)')
+    .addHelpText('after', `\n${CONTAINER_NOTE}\nKeys: --key-from-stdin, or run in a terminal to be asked with a hidden prompt.`)
+    .action(async (kind, urlArg, opts) => {
+      auth.requireAuth();
+      const p = providerFor(kind);
+      if (!p) throw new Error(`No provider called "${kind}". Use one of: ${KINDS.join(', ')}`);
+      if (urlArg && (looksLikeKey(urlArg) || (p.card && !p.url))) throw new Error('never pass a key as an argument (it would sit in your shell history and process list). Use --key-from-stdin, or run in a terminal to be asked.');
+      const a = api();
+      const url = opts.url || urlArg || '';
+      let r;
+      if (p.id === 'ollama') {
+        r = await connectOllamaFlow(a, [url, opts.model].filter(Boolean).join(' '));
+        say(r.lines);
+        if (r.privateAsk) {
+          const q = `Connect to ${r.privateAsk.host}? It's on your private network. Quox saves only ${r.privateAsk.origin}, after the server checks it answers as Ollama.`;
+          let yes = Boolean(opts.yes);
+          if (!yes && io.isTTY()) yes = await io.confirm(q);
+          if (!yes && !io.isTTY()) throw new Error(`${r.privateAsk.host} is on your private network. Run again with --yes to confirm this one address. Nothing was saved.`);
+          if (!yes) throw new Error(`Left blocked: ${r.privateAsk.host} was not connected. Nothing was saved.`);
+          r = await r.privateAsk.retry();
+          say(r.lines);
+        }
+      } else if (p.url) {
+        r = await connectCompatFlow(a, p.id, [url, opts.model].filter(Boolean).join(' '));
+        say(r.lines);
+        if (r.needsKey) { r = await connectFlow(a, 'custom', await readKey(PROVIDERS.custom, opts), r.extra); printInfo(r.text); if (r.disclosure) printInfo(r.disclosure); }
+      } else {
+        r = await connectFlow(a, p.id, await readKey(p, opts));
+        printInfo(r.text);
+        if (r.ok && r.disclosure) printInfo(r.disclosure);
+      }
+      if (r?.lanOffer) printInfo('  From the CLI an instance admin allows private targets with: quox server config lan-targets on   then run this again.');
+      if (!r?.ok) throw new Error(r?.text || `${p.name} was not connected. Nothing was saved.`);
+      await consentAfter(p.type);
+    });
+
+  // ── provider test ──────────────────────────────────────────────────────────
+  provider
+    .command('test')
+    .description('Test the stored connection for a provider (or every default connection) through the vault test')
+    .argument('[kind]', 'provider to test (default: every connected provider)')
+    .action(async (kind) => {
+      auth.requireAuth();
+      const p = kind ? providerFor(kind) : null;
+      if (kind && !p) throw new Error(`No provider called "${kind}". Use one of: ${KINDS.join(', ')}`);
+      const vault = await api().connections();
+      if (!vault?.ok) throw new Error(`Could not read the vault: ${vault?.error || 'no answer'}`);
+      const types = new Set(p ? [p.type] : Object.values(PROVIDERS).map((x) => x.type));
+      const rows = vault.rows.filter((r) => types.has(r.integration_type) && (r.is_default === 1 || r.is_default === true));
+      if (!rows.length) throw new Error(p ? `No ${p.id} connection is stored for this org. Connect one: quox provider connect ${p.id}` : 'No provider connection is stored for this org. Connect one: quox provider connect <kind>');
+      const orgId = resolveOrgId(auth, program);
+      let failed = 0;
+      for (const row of rows) {
+        const name = (Object.values(PROVIDERS).find((x) => x.type === row.integration_type) || {}).name || row.integration_type;
+        const ep = resolveEndpoint('vault.test', { orgId, id: row.id });
+        let res;
+        try { res = await client.post(ep.path, { service: ep.service, retries: 0 }); }
+        catch (e) { res = { success: false, message: e?.message || 'failed' }; }
+        if (res?.success === false) { failed++; printInfo(`✖ ${name}  ${row.label || row.id}  failed: ${res?.message || 'no reason given'}`); }
+        else printInfo(`✔ ${name}  ${row.label || row.id}  ok${res?.message ? `: ${res.message}` : ''}`);
+      }
+      if (failed) process.exitCode = 1;
+    });
+}