ticlawk 0.1.16-dev.10 → 0.1.16-dev.12

package/src/cli/agent-commands.mjs

@@ -160,6 +160,13 @@ export async function runMessageSendCommand(args) {
     mediaAssetIds.push(upload.assetId);
   }
 
+  // Optional --kind <s> classifies the message via metadata.kind. The
+  // canonical user-facing value is 'report' (奏折 surface). Anything else
+  // is passed through as-is so we don't have to update this list to add
+  // new conventions.
+  const kind = getArg(args, 'kind');
+  const metadata = kind ? { kind } : undefined;
+
   const body = {
     target,
     conversation_id: conversationId,
@@ -167,6 +174,7 @@ export async function runMessageSendCommand(args) {
     seen_up_to_seq: getNumberArg(args, 'seen-up-to-seq'),
     reply_to_message_id: getArg(args, 'reply-to'),
     media_asset_ids: mediaAssetIds.length > 0 ? mediaAssetIds : undefined,
+    metadata,
   };
   const res = await daemonRequest({
     method: 'POST',
@@ -800,6 +808,338 @@ export async function runGroupMembersCommand(args) {
   return exitFromStatus(res.statusCode);
 }
 
+export async function runWorkstreamCreateCommand(args) {
+  const env = requireAgentEnv();
+  const name = getArg(args, 'name');
+  if (!name) { console.error('--name is required'); return 2; }
+  const description = getArg(args, 'description');
+  const memberArgs = args.member;
+  const memberAgentIds = Array.isArray(memberArgs)
+    ? memberArgs
+    : memberArgs ? [memberArgs] : [];
+  // Optional charter from stdin when --charter is supplied with no value
+  let charter = null;
+  if (args.charter === true) {
+    charter = await readStdin();
+  } else if (typeof args.charter === 'string') {
+    charter = args.charter;
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/workstream/create',
+    headers: commonHeaders(env),
+    body: {
+      name,
+      description,
+      charter,
+      member_agent_ids: memberAgentIds.map((s) => String(s).trim()).filter(Boolean),
+    },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runWorkstreamDeleteCommand(args) {
+  const env = requireAgentEnv();
+  const target = getArg(args, 'target');
+  const conversationId = getArg(args, 'conversation-id');
+  if (!target && !conversationId) {
+    console.error('--target or --conversation-id is required');
+    return 2;
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/workstream/delete',
+    headers: commonHeaders(env),
+    body: { target, conversation_id: conversationId },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runWorkstreamListCommand(args) {
+  const env = requireAgentEnv();
+  const res = await daemonRequest({
+    method: 'GET',
+    path: '/agent/workstream/list',
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runAgentCreateCommand(args) {
+  const env = requireAgentEnv();
+  const name = getArg(args, 'name');
+  const runtime = getArg(args, 'runtime');
+  if (!name) { console.error('--name is required'); return 2; }
+  if (!runtime) { console.error('--runtime is required'); return 2; }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/agent/create',
+    headers: commonHeaders(env),
+    body: {
+      name,
+      runtime,
+      description: getArg(args, 'description'),
+      display_name: getArg(args, 'display-name'),
+      model: getArg(args, 'model'),
+    },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runAgentDeleteCommand(args) {
+  const env = requireAgentEnv();
+  const agentId = getArg(args, 'agent-id');
+  if (!agentId) { console.error('--agent-id is required'); return 2; }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/agent/delete',
+    headers: commonHeaders(env),
+    body: { agent_id: agentId },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+function readJsonFromFileOrInline(value) {
+  if (!value) return null;
+  // Accept either a path to a .json file or a raw JSON string.
+  try {
+    return JSON.parse(value);
+  } catch {}
+  try {
+    const fs = require('node:fs');
+    const txt = fs.readFileSync(value, 'utf8');
+    return JSON.parse(txt);
+  } catch (err) {
+    throw new Error(`could not parse JSON from ${value}: ${err?.message || err}`);
+  }
+}
+
+export async function runServiceCreateCommand(args) {
+  const env = requireAgentEnv();
+  const name = getArg(args, 'name');
+  if (!name) { console.error('--name is required'); return 2; }
+  const description = getArg(args, 'description');
+  let contractSchema = null;
+  let endpointConfig = null;
+  try {
+    const contractRaw = getArg(args, 'contract');
+    if (contractRaw) contractSchema = readJsonFromFileOrInline(contractRaw);
+    const endpointRaw = getArg(args, 'endpoint');
+    if (endpointRaw) endpointConfig = readJsonFromFileOrInline(endpointRaw);
+  } catch (err) {
+    console.error(err.message);
+    return 2;
+  }
+  if (!endpointConfig) { console.error('--endpoint <path-or-json> is required'); return 2; }
+  const res = await daemonRequest({
+    method: 'POST', path: '/agent/service/create',
+    headers: commonHeaders(env),
+    body: { name, description, contract_schema: contractSchema, endpoint_config: endpointConfig },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runServiceUpdateCommand(args) {
+  const env = requireAgentEnv();
+  const serviceId = getArg(args, 'service-id');
+  if (!serviceId) { console.error('--service-id is required'); return 2; }
+  const body = { service_id: serviceId };
+  if (getArg(args, 'description')) body.description = getArg(args, 'description');
+  if (getArg(args, 'contract')) body.contract_schema = readJsonFromFileOrInline(getArg(args, 'contract'));
+  if (getArg(args, 'endpoint')) body.endpoint_config = readJsonFromFileOrInline(getArg(args, 'endpoint'));
+  if (getArg(args, 'status')) body.status = getArg(args, 'status');
+  const res = await daemonRequest({
+    method: 'POST', path: '/agent/service/update',
+    headers: commonHeaders(env), body,
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runServiceDeleteCommand(args) {
+  const env = requireAgentEnv();
+  const serviceId = getArg(args, 'service-id');
+  if (!serviceId) { console.error('--service-id is required'); return 2; }
+  const res = await daemonRequest({
+    method: 'POST', path: '/agent/service/delete',
+    headers: commonHeaders(env),
+    body: { service_id: serviceId },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runServiceListCommand(args) {
+  const env = requireAgentEnv();
+  const res = await daemonRequest({
+    method: 'GET', path: '/agent/service/list',
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runServiceInfoCommand(args) {
+  const env = requireAgentEnv();
+  const name = getArg(args, 'name');
+  if (!name) { console.error('--name is required'); return 2; }
+  const params = new URLSearchParams();
+  params.set('name', name);
+  const res = await daemonRequest({
+    method: 'GET', path: `/agent/service/info?${params}`,
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runServiceCallCommand(args) {
+  const env = requireAgentEnv();
+  const name = getArg(args, 'name');
+  if (!name) { console.error('--name is required'); return 2; }
+  const inputText = await readStdin();
+  let input = null;
+  if (inputText && inputText.trim().length > 0) {
+    try {
+      input = JSON.parse(inputText);
+    } catch (err) {
+      console.error('stdin must be JSON for service call input');
+      return 2;
+    }
+  }
+  const res = await daemonRequest({
+    method: 'POST', path: '/agent/service/call',
+    headers: commonHeaders(env),
+    body: { name, input },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runCredentialRequestCommand(args) {
+  const env = requireAgentEnv();
+  const name = getArg(args, 'name');
+  if (!name) { console.error('--name is required (e.g. GEMINI_API_KEY)'); return 2; }
+  const description = getArg(args, 'description');
+  const workstream = getArg(args, 'workstream');
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/credential/request',
+    headers: commonHeaders(env),
+    body: {
+      name,
+      description,
+      target: workstream,
+    },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runDashboardSetCommand(args) {
+  const env = requireAgentEnv();
+  const target = getArg(args, 'target');
+  const conversationId = getArg(args, 'conversation-id');
+  if (!target && !conversationId) {
+    console.error('--target or --conversation-id is required');
+    return 2;
+  }
+  // Body is read from stdin as JSON: { data_json?, html_template? }
+  const stdinText = await readStdin();
+  let payload = {};
+  if (stdinText && stdinText.trim().length > 0) {
+    try {
+      payload = JSON.parse(stdinText);
+    } catch (err) {
+      console.error('stdin must be JSON: { data_json?, html_template? }');
+      return 2;
+    }
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/dashboard/set',
+    headers: commonHeaders(env),
+    body: {
+      target,
+      conversation_id: conversationId,
+      ...(('data_json' in payload) ? { data_json: payload.data_json } : {}),
+      ...(('html_template' in payload) ? { html_template: payload.html_template } : {}),
+    },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runDashboardGetCommand(args) {
+  const env = requireAgentEnv();
+  const target = getArg(args, 'target');
+  const conversationId = getArg(args, 'conversation-id');
+  if (!target && !conversationId) {
+    console.error('--target or --conversation-id is required');
+    return 2;
+  }
+  const params = new URLSearchParams();
+  if (target) params.set('target', target);
+  if (conversationId) params.set('conversation_id', conversationId);
+  const res = await daemonRequest({
+    method: 'GET',
+    path: `/agent/dashboard/get?${params}`,
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runWorkstreamCharterGetCommand(args) {
+  const env = requireAgentEnv();
+  const target = getArg(args, 'target');
+  const conversationId = getArg(args, 'conversation-id');
+  if (!target && !conversationId) {
+    console.error('--target or --conversation-id is required');
+    return 2;
+  }
+  const params = new URLSearchParams();
+  if (target) params.set('target', target);
+  if (conversationId) params.set('conversation_id', conversationId);
+  const res = await daemonRequest({
+    method: 'GET',
+    path: `/agent/workstream/charter/get?${params}`,
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runWorkstreamCharterSetCommand(args) {
+  const env = requireAgentEnv();
+  const target = getArg(args, 'target');
+  const conversationId = getArg(args, 'conversation-id');
+  if (!target && !conversationId) {
+    console.error('--target or --conversation-id is required');
+    return 2;
+  }
+  // Body from stdin (heredoc / pipe). Empty input clears the charter.
+  const charter = await readStdin();
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/workstream/charter/set',
+    headers: commonHeaders(env),
+    body: {
+      target,
+      conversation_id: conversationId,
+      charter: charter ?? '',
+    },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
 export async function runServerInfoCommand(args) {
   const env = requireAgentEnv();
   const params = new URLSearchParams();
@@ -815,8 +1155,11 @@ export async function runServerInfoCommand(args) {
 
 export const AGENT_COMMAND_HELP = {
   message: `ticlawk message <send|read|check|search|react>
-  ticlawk message send --target "<target>" [--seen-up-to-seq N] [--reply-to <msg-id>] [--attach <file> ...]
+  ticlawk message send --target "<target>" [--seen-up-to-seq N] [--reply-to <msg-id>] [--attach <file> ...] [--kind <kind>]
     Body is read from stdin (use <<'EOF' ... EOF for multiline).
+    --kind <kind> tags this message via metadata.kind. The CoS uses
+      --kind report to publish a 奏折 / status report that the Office
+      tab can list separately.
     Targets:
       dm:@<user>         private message
       #<group>           group conversation
@@ -861,6 +1204,59 @@ export const AGENT_COMMAND_HELP = {
   ticlawk task unclaim --task-id <id>
   ticlawk task update --task-id <id> --status <todo|in_progress|in_review|done|canceled>
   ticlawk task list [--target <target>]
+`,
+  workstream: `ticlawk workstream <create|delete|list|charter>
+  workstream create --name X [--description Y] [--member <agent-id> ...] [--charter [<text>]]
+    CoS-only. Create a managed group conversation. If --charter has no
+    value, body is read from stdin (heredoc / pipe). Empty stdin = no
+    charter. Members are joined alongside CoS.
+  workstream delete --target "#<group>"
+    CoS-only. Hard-delete the workstream (messages, members, deliveries
+    cascade). Use carefully.
+  workstream list
+    List all workstreams (group conversations) owned by your user.
+  workstream charter get --target "#<group>"
+    Print the workstream's charter (CoS-authored markdown).
+  workstream charter set --target "#<group>"   # body via stdin
+    Replace the workstream charter. CoS-only — non-CoS callers get 403.
+    Empty stdin clears the charter. Hard cap 4096 chars (DB-enforced).
+`,
+  service: `ticlawk service <create|update|delete|list|info|call>
+  service create --name X --endpoint <path-or-json> [--description Y] [--contract <path-or-json>]
+    CoS-only. Register a callable service. --endpoint takes either a
+    .json file path or a JSON string; same for --contract.
+    endpoint_config shape: { url, method?, headers? }.
+  service update --service-id <id> [--description Y] [--contract <json>] [--endpoint <json>] [--status <active|down|archived>]
+    CoS-only.
+  service delete --service-id <id>
+    CoS-only. Soft-archives.
+  service list
+    Any agent. Returns active services (no endpoint_config).
+  service info --name X
+    Any agent. Returns contract_schema + description.
+  service call --name X    # input from stdin (JSON)
+    Any agent. Backend proxies to endpoint_config.url. No retry.
+`,
+  credential: `ticlawk credential request --name <ENV_VAR> [--description Y] [--workstream "#<ws>"]
+    CoS-only. Pre-allocate a credential slot. Response includes a deep
+    link the user opens in the mobile app (Settings → Connections) to
+    fill the value. Once filled, the daemon injects it as an env var
+    when spawning agents.
+`,
+  dashboard: `ticlawk dashboard <set|get> --target "#<workstream>"
+  dashboard set --target "#<workstream>"   # body via stdin (JSON)
+    CoS-only. stdin = { "data_json": ..., "html_template": "..." }.
+    Either field may be omitted (leaves unchanged) or null (clears).
+  dashboard get --target "#<workstream>"
+    Any member of the workstream can read.
+`,
+  agent: `ticlawk agent <create|delete>
+  agent create --name X --runtime <claude_code|codex|opencode|openclaw|pi> [--description Y] [--display-name N] [--model M]
+    CoS-only. Pre-allocate an agent slot (status='unpaired'). User
+    later pairs a runtime to fill it.
+  agent delete --agent-id <id>
+    CoS-only. Soft-delete the agent (status='archived'). Cannot archive
+    self.
 `,
   group: `ticlawk group <create|members>
   ticlawk group create --name <n> [--description <d>] [--member <agent-id> ...]