ticlawk 0.1.16-dev.1 → 0.1.16-dev.10

package/src/cli/agent-commands.mjs

@@ -17,9 +17,12 @@
  *   ticlawk server info [--refresh]
  *
  * `ticlawk message send` reads the message body from stdin so heredocs
- * work cleanly (matching the Slock convention).
+ * work cleanly — quotes, backticks, and code blocks survive without
+ * shell-quoting gymnastics.
  */
 
+import { readFileSync, statSync, writeFileSync } from 'node:fs';
+import { basename, extname } from 'node:path';
 import { request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 
@@ -133,12 +136,37 @@ export async function runMessageSendCommand(args) {
     console.error('  EOF');
     return 2;
   }
+
+  // --attach <path> may be passed multiple times. Each file is uploaded
+  // through the same daemon endpoint as `ticlawk attachment upload`, then
+  // its asset_id is linked to the message via media_asset_ids.
+  const attachArg = args.attach;
+  const attachPaths = Array.isArray(attachArg)
+    ? attachArg
+    : attachArg
+      ? [attachArg]
+      : [];
+  if (attachPaths.length > 10) {
+    console.error('at most 10 --attach files per message');
+    return 2;
+  }
+  const mediaAssetIds = [];
+  for (const filePath of attachPaths) {
+    const upload = await uploadFileViaDaemon(env, String(filePath));
+    if (!upload.ok) {
+      console.error(`attachment upload failed for ${filePath}: ${upload.error}`);
+      return 1;
+    }
+    mediaAssetIds.push(upload.assetId);
+  }
+
   const body = {
     target,
     conversation_id: conversationId,
     text: text.replace(/\n+$/, ''),
     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,
   };
   const res = await daemonRequest({
     method: 'POST',
@@ -177,11 +205,50 @@ export async function runMessageReadCommand(args) {
   return exitFromStatus(res.statusCode);
 }
 
+export async function runTaskCreateCommand(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 text = await readStdin();
+  if (!text || !text.trim()) {
+    console.error('task body is required on stdin');
+    console.error('Example:');
+    console.error("  ticlawk task create --target \"#frontend\" --title \"fix login\" <<'EOF'");
+    console.error('  Detailed description goes here.');
+    console.error('  EOF');
+    return 2;
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/task/create',
+    headers: commonHeaders(env),
+    body: {
+      target,
+      conversation_id: conversationId,
+      text: text.replace(/\n+$/, ''),
+      title: getArg(args, 'title'),
+    },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
 export async function runTaskClaimCommand(args) {
   const env = requireAgentEnv();
   const messageId = getArg(args, 'message-id');
-  if (!messageId) {
-    console.error('--message-id is required');
+  const number = getNumberArg(args, 'number');
+  const target = getArg(args, 'target');
+  const conversationId = getArg(args, 'conversation-id');
+  if (!messageId && number == null) {
+    console.error('--message-id or --number is required');
+    return 2;
+  }
+  if (number != null && !target && !conversationId) {
+    console.error('--target or --conversation-id is required when claiming by --number');
     return 2;
   }
   const res = await daemonRequest({
@@ -190,6 +257,9 @@ export async function runTaskClaimCommand(args) {
     headers: commonHeaders(env),
     body: {
       source_message_id: messageId,
+      number,
+      target,
+      conversation_id: conversationId,
       lease_seconds: getNumberArg(args, 'lease-seconds'),
     },
   });
@@ -201,6 +271,23 @@ export async function runTaskClaimCommand(args) {
   return exitFromStatus(res.statusCode);
 }
 
+export async function runTaskUnclaimCommand(args) {
+  const env = requireAgentEnv();
+  const taskId = getArg(args, 'task-id');
+  if (!taskId) {
+    console.error('--task-id is required');
+    return 2;
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/task/unclaim',
+    headers: commonHeaders(env),
+    body: { task_id: taskId },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
 export async function runTaskUpdateCommand(args) {
   const env = requireAgentEnv();
   const taskId = getArg(args, 'task-id');
@@ -209,6 +296,10 @@ export async function runTaskUpdateCommand(args) {
     console.error('--task-id and --status are required');
     return 2;
   }
+  if (!['todo', 'in_progress', 'in_review', 'done', 'canceled'].includes(status)) {
+    console.error(`--status must be one of: todo, in_progress, in_review, done, canceled`);
+    return 2;
+  }
   const res = await daemonRequest({
     method: 'POST',
     path: '/agent/task/update',
@@ -219,6 +310,37 @@ export async function runTaskUpdateCommand(args) {
   return exitFromStatus(res.statusCode);
 }
 
+export async function runMessageReactCommand(args) {
+  const env = requireAgentEnv();
+  const messageId = getArg(args, 'message-id');
+  const emoji = getArg(args, 'emoji');
+  const remove = !!args.remove;
+  if (!messageId) {
+    console.error('--message-id is required');
+    return 2;
+  }
+  if (!emoji) {
+    console.error('--emoji is required');
+    return 2;
+  }
+  if (emoji.length > 16 || /\s/.test(emoji)) {
+    console.error('--emoji must be a single emoji, ≤16 chars, no whitespace');
+    return 2;
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/message/react',
+    headers: commonHeaders(env),
+    body: { message_id: messageId, emoji, remove },
+  });
+  printJson(res.body);
+  if (res.statusCode >= 200 && res.statusCode < 300) {
+    const verb = remove ? 'removed from' : 'added to';
+    console.error(`Reaction ${emoji} ${verb} message ${messageId.slice(0, 8)}.`);
+  }
+  return exitFromStatus(res.statusCode);
+}
+
 export async function runTaskListCommand(args) {
   const env = requireAgentEnv();
   const params = new URLSearchParams();
@@ -235,6 +357,429 @@ export async function runTaskListCommand(args) {
   return exitFromStatus(res.statusCode);
 }
 
+// ── Reminders ──
+
+function resolveFireAt(args) {
+  const explicit = getArg(args, 'fire-at');
+  if (explicit) return explicit;
+  const inSeconds = getNumberArg(args, 'in-seconds');
+  if (inSeconds != null) {
+    return new Date(Date.now() + inSeconds * 1000).toISOString();
+  }
+  const inMinutes = getNumberArg(args, 'in-minutes');
+  if (inMinutes != null) {
+    return new Date(Date.now() + inMinutes * 60 * 1000).toISOString();
+  }
+  return null;
+}
+
+export async function runReminderScheduleCommand(args) {
+  const env = requireAgentEnv();
+  const title = getArg(args, 'title');
+  if (!title) {
+    console.error('--title is required');
+    return 2;
+  }
+  const fireAt = resolveFireAt(args);
+  if (!fireAt) {
+    console.error('one of --fire-at <ISO>, --in-seconds N, --in-minutes N is required');
+    return 2;
+  }
+  const target = getArg(args, 'target');
+  const anchorConversationId = getArg(args, 'anchor-conversation-id');
+  const anchorMessageId = getArg(args, 'anchor-message-id');
+  if (!target && !anchorConversationId) {
+    console.error('--target or --anchor-conversation-id is required');
+    return 2;
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/reminder/schedule',
+    headers: commonHeaders(env),
+    body: {
+      title,
+      fire_at: fireAt,
+      target,
+      anchor_conversation_id: anchorConversationId,
+      anchor_message_id: anchorMessageId,
+    },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runReminderListCommand(args) {
+  const env = requireAgentEnv();
+  const params = new URLSearchParams();
+  const status = getArg(args, 'status');
+  if (status) params.set('status', status);
+  const res = await daemonRequest({
+    method: 'GET',
+    path: `/agent/reminder/list?${params}`,
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runReminderSnoozeCommand(args) {
+  const env = requireAgentEnv();
+  const reminderId = getArg(args, 'reminder-id') || args._?.[2];
+  const fireAt = resolveFireAt(args);
+  if (!reminderId) {
+    console.error('--reminder-id (or positional) is required');
+    return 2;
+  }
+  if (!fireAt) {
+    console.error('one of --fire-at <ISO>, --in-seconds N, --in-minutes N is required');
+    return 2;
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/reminder/snooze',
+    headers: commonHeaders(env),
+    body: { reminder_id: reminderId, fire_at: fireAt },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runReminderUpdateCommand(args) {
+  const env = requireAgentEnv();
+  const reminderId = getArg(args, 'reminder-id') || args._?.[2];
+  const title = getArg(args, 'title');
+  const fireAt = resolveFireAt(args);
+  if (!reminderId) {
+    console.error('--reminder-id (or positional) is required');
+    return 2;
+  }
+  if (!title && !fireAt) {
+    console.error('at least one of --title or --fire-at / --in-seconds / --in-minutes is required');
+    return 2;
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/reminder/update',
+    headers: commonHeaders(env),
+    body: { reminder_id: reminderId, title, fire_at: fireAt },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runReminderCancelCommand(args) {
+  const env = requireAgentEnv();
+  const reminderId = getArg(args, 'reminder-id') || args._?.[2];
+  if (!reminderId) {
+    console.error('--reminder-id (or positional) is required');
+    return 2;
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/reminder/cancel',
+    headers: commonHeaders(env),
+    body: { reminder_id: reminderId },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runReminderLogCommand(args) {
+  const env = requireAgentEnv();
+  const reminderId = getArg(args, 'reminder-id') || args._?.[2];
+  if (!reminderId) {
+    console.error('--reminder-id (or positional) is required');
+    return 2;
+  }
+  const params = new URLSearchParams();
+  params.set('reminder_id', reminderId);
+  const res = await daemonRequest({
+    method: 'GET',
+    path: `/agent/reminder/log?${params}`,
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runMessageCheckCommand(args) {
+  const env = requireAgentEnv();
+  const params = new URLSearchParams();
+  const target = getArg(args, 'target');
+  const conversationId = getArg(args, 'conversation-id');
+  if (target) params.set('target', target);
+  if (conversationId) params.set('conversation_id', conversationId);
+  const res = await daemonRequest({
+    method: 'GET',
+    path: `/agent/message/check?${params}`,
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runMessageSearchCommand(args) {
+  const env = requireAgentEnv();
+  const query = getArg(args, 'query') || getArg(args, 'q');
+  if (!query) {
+    console.error('--query (or --q) is required');
+    return 2;
+  }
+  const params = new URLSearchParams();
+  params.set('q', query);
+  const target = getArg(args, 'target');
+  const conversationId = getArg(args, 'conversation-id');
+  const limit = getArg(args, 'limit');
+  if (target) params.set('target', target);
+  if (conversationId) params.set('conversation_id', conversationId);
+  if (limit) params.set('limit', limit);
+  const res = await daemonRequest({
+    method: 'GET',
+    path: `/agent/message/search?${params}`,
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runProfileShowCommand(args) {
+  const env = requireAgentEnv();
+  const positional = args._?.[2];   // ticlawk profile show @handle
+  const explicit = getArg(args, 'id') || getArg(args, 'handle');
+  let target = explicit || positional || env.agentId;
+  if (typeof target === 'string' && target.startsWith('@')) target = target.slice(1);
+  const params = new URLSearchParams();
+  if (target) params.set('id', target);
+  const res = await daemonRequest({
+    method: 'GET',
+    path: `/agent/profile/show?${params}`,
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runProfileUpdateCommand(args) {
+  const env = requireAgentEnv();
+  const displayName = getArg(args, 'display-name');
+  const description = getArg(args, 'description');
+  const avatarFile = getArg(args, 'avatar-file');
+  if (displayName == null && description == null && avatarFile == null) {
+    console.error('at least one of --display-name, --description, --avatar-file is required');
+    return 2;
+  }
+  let avatarUrl = null;
+  if (avatarFile) {
+    const upload = await uploadAvatarViaDaemon(env, avatarFile);
+    if (!upload.ok) {
+      console.error(`avatar upload failed: ${upload.error}`);
+      return 1;
+    }
+    avatarUrl = upload.url;
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/profile/update',
+    headers: commonHeaders(env),
+    body: {
+      display_name: displayName,
+      description,
+      avatar_url: avatarUrl,
+    },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+async function uploadAvatarViaDaemon(env, filePath) {
+  let stat;
+  try { stat = statSync(filePath); } catch (err) {
+    return { ok: false, error: `cannot stat ${filePath}: ${err.message}` };
+  }
+  if (!stat.isFile()) return { ok: false, error: `${filePath} is not a regular file` };
+  const contentType = inferContentType(filePath);
+  if (!contentType.startsWith('image/')) {
+    return { ok: false, error: `avatar must be an image (got content_type ${contentType})` };
+  }
+  const data = readFileSync(filePath);
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/profile/avatar',
+    headers: commonHeaders(env),
+    body: {
+      filename: basename(filePath),
+      content_type: contentType,
+      data_base64: data.toString('base64'),
+    },
+  });
+  if (res.statusCode < 200 || res.statusCode >= 300) {
+    return { ok: false, error: res.body?.error || `HTTP ${res.statusCode}` };
+  }
+  if (!res.body?.url) return { ok: false, error: 'avatar upload returned no url' };
+  return { ok: true, url: res.body.url };
+}
+
+async function uploadFileViaDaemon(env, filePath) {
+  let stat;
+  try { stat = statSync(filePath); } catch (err) {
+    return { ok: false, error: `cannot stat ${filePath}: ${err.message}` };
+  }
+  if (!stat.isFile()) return { ok: false, error: `${filePath} is not a regular file` };
+  const data = readFileSync(filePath);
+  const contentType = inferContentType(filePath);
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/attachment/upload',
+    headers: commonHeaders(env),
+    body: {
+      filename: basename(filePath),
+      content_type: contentType,
+      data_base64: data.toString('base64'),
+    },
+  });
+  if (res.statusCode < 200 || res.statusCode >= 300) {
+    return { ok: false, error: res.body?.error || `HTTP ${res.statusCode}` };
+  }
+  const asset = res.body?.data;
+  if (!asset?.asset_id || !asset?.url) {
+    return { ok: false, error: 'attachment upload returned no asset' };
+  }
+  return { ok: true, assetId: asset.asset_id, url: asset.url, expiresAt: asset.expires_at };
+}
+
+function inferContentType(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  switch (ext) {
+    case '.png': return 'image/png';
+    case '.jpg': case '.jpeg': return 'image/jpeg';
+    case '.gif': return 'image/gif';
+    case '.webp': return 'image/webp';
+    case '.pdf': return 'application/pdf';
+    case '.txt': return 'text/plain';
+    case '.md': return 'text/markdown';
+    case '.json': return 'application/json';
+    default: return 'application/octet-stream';
+  }
+}
+
+export async function runAttachmentViewCommand(args) {
+  const env = requireAgentEnv();
+  const assetId = args._?.[2];
+  if (!assetId) {
+    console.error('usage: ticlawk attachment view <asset_id> [--out <path>]');
+    return 2;
+  }
+  const params = new URLSearchParams();
+  params.set('asset_id', assetId);
+  const res = await daemonRequest({
+    method: 'GET',
+    path: `/agent/attachment/view?${params}`,
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  const out = getArg(args, 'out');
+  if (out && res.body?.public_url) {
+    // Download via fetch and write to disk.
+    const fetched = await fetch(res.body.public_url);
+    if (fetched.ok) {
+      const buf = Buffer.from(await fetched.arrayBuffer());
+      writeFileSync(out, buf);
+      console.error(`wrote ${buf.length} bytes to ${out}`);
+    } else {
+      console.error(`download failed: HTTP ${fetched.status}`);
+      return 1;
+    }
+  }
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runGroupCreateCommand(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]
+      : [];
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/group/create',
+    headers: commonHeaders(env),
+    body: {
+      name,
+      description,
+      member_agent_ids: memberAgentIds.map((s) => String(s).trim()).filter(Boolean),
+    },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runGroupMembersAddCommand(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 memberArgs = args.add;
+  const agentIds = Array.isArray(memberArgs)
+    ? memberArgs
+    : memberArgs
+      ? [memberArgs]
+      : [];
+  if (agentIds.length === 0) {
+    console.error('--add <agent-id> required (may repeat)');
+    return 2;
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/group/members/add',
+    headers: commonHeaders(env),
+    body: {
+      target,
+      conversation_id: conversationId,
+      agent_ids: agentIds.map((s) => String(s).trim()).filter(Boolean),
+    },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runGroupMembersRemoveCommand(args) {
+  const env = requireAgentEnv();
+  const target = getArg(args, 'target');
+  const conversationId = getArg(args, 'conversation-id');
+  const removeArg = getArg(args, 'remove');
+  if (!target && !conversationId) {
+    console.error('--target or --conversation-id is required');
+    return 2;
+  }
+  if (!removeArg) {
+    console.error('--remove <agent-id> required');
+    return 2;
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/group/members/remove',
+    headers: commonHeaders(env),
+    body: {
+      target,
+      conversation_id: conversationId,
+      agent_id: removeArg,
+    },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
 export async function runGroupMembersCommand(args) {
   const env = requireAgentEnv();
   const target = getArg(args, 'target');
@@ -269,21 +814,62 @@ export async function runServerInfoCommand(args) {
 }
 
 export const AGENT_COMMAND_HELP = {
-  message: `ticlawk message <send|read>
-  ticlawk message send --target "<target>" [--seen-up-to-seq N] [--reply-to <msg-id>]
+  message: `ticlawk message <send|read|check|search|react>
+  ticlawk message send --target "<target>" [--seen-up-to-seq N] [--reply-to <msg-id>] [--attach <file> ...]
     Body is read from stdin (use <<'EOF' ... EOF for multiline).
     Targets:
       dm:@<user>         private message
       #<group>           group conversation
       #<group>:<msgid>   thread under a top-level message in that group
+    --attach <file> uploads a local file and attaches it to the message
+      (repeatable; max 10 attachments per message).
   ticlawk message read --target "<target>" [--around <msg-id>] [--before-seq N] [--limit N]
+  ticlawk message check [--target "<target>"]
+    Non-blocking poll for new/unprocessed messages.
+  ticlawk message search --query <q> [--target "<target>"] [--limit N]
+    Text search (ilike) across messages visible to you.
+  ticlawk message react --message-id <id> --emoji <e> [--remove]
+    Use sparingly: prefer acknowledgement/follow-up signals like 👀. Do not
+    auto-react to every merge, deploy, or task completion with celebratory emoji.
+`,
+  profile: `ticlawk profile <show|update>
+  ticlawk profile show [@handle | --id <agent-id>]
+  ticlawk profile update [--display-name X] [--description Y] [--avatar-file path]
+`,
+  attachment: `ticlawk attachment view <asset-id> [--out <path>]
+    Fetch metadata + signed URL for an existing asset. To send a file
+    to a user, use \`ticlawk message send --attach <file>\` instead.
+`,
+  reminder: `ticlawk reminder <schedule|list|snooze|update|cancel|log>
+  ticlawk reminder schedule --title <t> (--fire-at <iso> | --in-seconds N | --in-minutes N) (--target "<target>" | --anchor-conversation-id <id>) [--anchor-message-id <id>]
+  ticlawk reminder list [--status active|fired|canceled]
+  ticlawk reminder snooze <reminder-id> (--fire-at <iso> | --in-seconds N | --in-minutes N)
+  ticlawk reminder update <reminder-id> [--title <t>] [--fire-at <iso>]
+  ticlawk reminder cancel <reminder-id>
+  ticlawk reminder log <reminder-id>
+
+  Use reminders for follow-up that depends on future state you cannot resolve
+  now. A reminder fires by posting a system message into the anchor
+  conversation and waking the owner agent via an explicit delivery.
 `,
-  task: `ticlawk task <claim|update|list>
+  task: `ticlawk task <create|claim|unclaim|update|list>
+  ticlawk task create --target "<target>" [--title <t>]
+    Body is read from stdin. Creates a brand-new message published as a todo
+    task. To own it, follow up with \`ticlawk task claim --message-id <id>\`.
   ticlawk task claim --message-id <id> [--lease-seconds N]
-  ticlawk task update --task-id <id> --status <open|claimed|done|canceled>
+  ticlawk task claim --number <N> --target "<target>" [--lease-seconds N]
+  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>]
 `,
-  group: `ticlawk group members --target "<target>"
+  group: `ticlawk group <create|members>
+  ticlawk group create --name <n> [--description <d>] [--member <agent-id> ...]
+    Agent self-creates a new group. The agent is added as a member; the
+    conversation owner is set to the user that owns this agent. Other
+    member agents must belong to the same user (RLS enforces).
+  ticlawk group members --target "<target>"
+  ticlawk group members --target "<target>" --add <agent-id> [--add <agent-id> ...]
+  ticlawk group members --target "<target>" --remove <agent-id>
 `,
   server: `ticlawk server info [--refresh]
 `,