ticlawk 0.1.16-dev.1 → 0.1.16-dev.11

package/src/core/agent-cli-handlers.mjs

@@ -145,6 +145,10 @@ export async function handleMessageSend(req, body, ctx) {
     return { status: 400, body: { error: 'target or conversation_id is required' } };
   }
 
+  const mediaAssetIds = Array.isArray(body?.media_asset_ids)
+    ? body.media_asset_ids.map((v) => String(v).trim()).filter(Boolean)
+    : [];
+
   try {
     const data = await api.sendAgentMessage({
       actingAgentId,
@@ -153,6 +157,7 @@ export async function handleMessageSend(req, body, ctx) {
       seenUpToSeq: body?.seen_up_to_seq,
       replyToMessageId: body?.reply_to_message_id || threadRootMsgId || null,
       runtimeHostId: getRuntimeHostId(req, body),
+      mediaAssetIds,
     });
     debugLog('agent-cli', 'send.ok', {
       actingAgentId,
@@ -200,22 +205,86 @@ export async function handleMessageRead(req, query, ctx) {
   }
 }
 
+export async function handleTaskCreate(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+
+  const text = String(body?.text || '').trim();
+  if (!text) return { status: 400, body: { error: 'text is required' } };
+
+  let conversationId = body?.conversation_id || null;
+  if (!conversationId && body?.target) {
+    const resolved = await resolveTarget(actingAgentId, String(body.target));
+    if (resolved.error) return { status: 404, body: { error: resolved.error } };
+    conversationId = resolved.conversationId;
+  }
+  if (!conversationId) {
+    return { status: 400, body: { error: 'target or conversation_id is required' } };
+  }
+
+  try {
+    const data = await api.createAgentTask({
+      actingAgentId,
+      conversationId,
+      text,
+      title: body?.title ?? null,
+    });
+    debugLog('agent-cli', 'task.create', {
+      actingAgentId,
+      conversationId,
+      messageId: data?.message?.id,
+      taskNumber: data?.task?.number,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    debugError('agent-cli', 'task.create.failed', {
+      actingAgentId,
+      conversationId,
+      error: err?.message || String(err),
+    });
+    return { status: err?.status || 500, body: { error: err?.message || 'task create failed' } };
+  }
+}
+
 export async function handleTaskClaim(req, body, ctx) {
   const actingAgentId = getActingAgentId(req, body);
   const v = validateActingAgent(actingAgentId, ctx);
   if (!v.ok) return { status: v.status, body: { error: v.error } };
-  const sourceMessageId = body?.source_message_id || body?.message_id;
-  if (!sourceMessageId) return { status: 400, body: { error: 'source_message_id (or message_id) is required' } };
+  const sourceMessageId = body?.source_message_id || body?.message_id || null;
+  const number = body?.number != null ? Number(body.number) : null;
+
+  // Number-based claim needs the conversation_id to disambiguate. Allow
+  // the caller to pass either conversation_id directly or a target.
+  let conversationId = body?.conversation_id || null;
+  if (number != null && !conversationId && body?.target) {
+    const resolved = await resolveTarget(actingAgentId, String(body.target));
+    if (resolved.error) return { status: 404, body: { error: resolved.error } };
+    conversationId = resolved.conversationId;
+  }
+
+  if (!sourceMessageId && number == null) {
+    return { status: 400, body: { error: '--message-id or --number is required' } };
+  }
+  if (number != null && !conversationId) {
+    return { status: 400, body: { error: '--target or --conversation-id is required when claiming by number' } };
+  }
+
   try {
     const data = await api.claimAgentTask({
       actingAgentId,
       sourceMessageId,
+      conversationId,
+      number,
       leaseSeconds: body?.lease_seconds,
     });
     debugLog('agent-cli', 'task.claim', {
       actingAgentId,
-      sourceMessageId,
+      sourceMessageId: sourceMessageId || null,
+      number: number ?? null,
+      conversationId: conversationId || null,
       claimed: data?.claimed,
+      taskNumber: data?.task?.number || null,
     });
     return { status: data?.claimed === false ? 409 : 200, body: data };
   } catch (err) {
@@ -223,6 +292,27 @@ export async function handleTaskClaim(req, body, ctx) {
   }
 }
 
+export async function handleTaskUnclaim(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  if (!body?.task_id) return { status: 400, body: { error: 'task_id is required' } };
+  try {
+    const data = await api.unclaimAgentTask({
+      actingAgentId,
+      taskId: body.task_id,
+    });
+    debugLog('agent-cli', 'task.unclaim', {
+      actingAgentId,
+      taskId: body.task_id,
+      ok: data?.ok,
+    });
+    return { status: data?.ok ? 200 : 409, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'unclaim failed' } };
+  }
+}
+
 export async function handleTaskUpdate(req, body, ctx) {
   const actingAgentId = getActingAgentId(req, body);
   const v = validateActingAgent(actingAgentId, ctx);
@@ -276,6 +366,356 @@ export async function handleGroupMembers(req, query, ctx) {
   }
 }
 
+export async function handleMessageReact(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  const messageId = body?.message_id;
+  const emoji = body?.emoji;
+  const remove = !!body?.remove;
+  if (!messageId) return { status: 400, body: { error: 'message_id is required' } };
+  if (!emoji) return { status: 400, body: { error: 'emoji is required' } };
+  try {
+    const data = await api.reactToMessage({
+      actingAgentId, messageId, emoji, remove,
+    });
+    debugLog('agent-cli', remove ? 'message.unreact' : 'message.react', {
+      actingAgentId, messageId, emoji,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'react failed' } };
+  }
+}
+
+export async function handleReminderSchedule(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  if (!body?.title) return { status: 400, body: { error: 'title is required' } };
+  if (!body?.fire_at) return { status: 400, body: { error: 'fire_at (ISO timestamp) is required' } };
+
+  let anchorConversationId = body?.anchor_conversation_id || null;
+  if (!anchorConversationId && body?.target) {
+    const resolved = await resolveTarget(actingAgentId, String(body.target));
+    if (resolved.error) return { status: 404, body: { error: resolved.error } };
+    anchorConversationId = resolved.conversationId;
+  }
+  if (!anchorConversationId) {
+    return { status: 400, body: { error: '--target or --anchor-conversation-id required' } };
+  }
+
+  try {
+    const data = await api.scheduleAgentReminder({
+      actingAgentId,
+      title: body.title,
+      fireAt: body.fire_at,
+      anchorConversationId,
+      anchorMessageId: body?.anchor_message_id || null,
+    });
+    debugLog('agent-cli', 'reminder.schedule', {
+      actingAgentId,
+      reminderId: data?.data?.id,
+      fireAt: body.fire_at,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'schedule failed' } };
+  }
+}
+
+export async function handleReminderList(req, query, ctx) {
+  const actingAgentId = getActingAgentId(req, query);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  try {
+    const data = await api.listAgentReminders({
+      actingAgentId,
+      status: query?.status || null,
+    });
+    return { status: 200, body: { data } };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'list failed' } };
+  }
+}
+
+export async function handleReminderSnooze(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  if (!body?.reminder_id) return { status: 400, body: { error: 'reminder_id is required' } };
+  if (!body?.fire_at) return { status: 400, body: { error: 'fire_at is required' } };
+  try {
+    const data = await api.snoozeAgentReminder({
+      actingAgentId,
+      reminderId: body.reminder_id,
+      fireAt: body.fire_at,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'snooze failed' } };
+  }
+}
+
+export async function handleReminderUpdate(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  if (!body?.reminder_id) return { status: 400, body: { error: 'reminder_id is required' } };
+  try {
+    const data = await api.updateAgentReminder({
+      actingAgentId,
+      reminderId: body.reminder_id,
+      title: body?.title || null,
+      fireAt: body?.fire_at || null,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'update failed' } };
+  }
+}
+
+export async function handleReminderCancel(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  if (!body?.reminder_id) return { status: 400, body: { error: 'reminder_id is required' } };
+  try {
+    const data = await api.cancelAgentReminder({
+      actingAgentId,
+      reminderId: body.reminder_id,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'cancel failed' } };
+  }
+}
+
+export async function handleReminderLog(req, query, ctx) {
+  const actingAgentId = getActingAgentId(req, query);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  if (!query?.reminder_id) return { status: 400, body: { error: 'reminder_id is required' } };
+  try {
+    const data = await api.getAgentReminderLog({
+      actingAgentId,
+      reminderId: query.reminder_id,
+    });
+    return { status: 200, body: { data } };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'log failed' } };
+  }
+}
+
+export async function handleMessageCheck(req, query, ctx) {
+  const actingAgentId = getActingAgentId(req, query);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  let conversationId = query?.conversation_id || null;
+  if (!conversationId && query?.target) {
+    const resolved = await resolveTarget(actingAgentId, String(query.target));
+    if (!resolved.error) conversationId = resolved.conversationId;
+  }
+  try {
+    const data = await api.checkAgentMessages({ actingAgentId, conversationId });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'check failed' } };
+  }
+}
+
+export async function handleMessageSearch(req, query, ctx) {
+  const actingAgentId = getActingAgentId(req, query);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  if (!query?.q) return { status: 400, body: { error: 'q is required' } };
+  let conversationId = query?.conversation_id || null;
+  if (!conversationId && query?.target) {
+    const resolved = await resolveTarget(actingAgentId, String(query.target));
+    if (!resolved.error) conversationId = resolved.conversationId;
+  }
+  try {
+    const data = await api.searchAgentMessages({
+      actingAgentId,
+      query: query.q,
+      conversationId,
+      limit: query?.limit != null ? Number(query.limit) : null,
+    });
+    return { status: 200, body: { data } };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'search failed' } };
+  }
+}
+
+export async function handleProfileShow(req, query, ctx) {
+  const actingAgentId = getActingAgentId(req, query);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  const idOrHandle = query?.id || query?.handle || actingAgentId;
+  try {
+    const data = await api.getAgentProfile({ actingAgentId, idOrHandle });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'profile show failed' } };
+  }
+}
+
+export async function handleProfileUpdate(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  try {
+    const data = await api.patchAgentProfile({
+      actingAgentId,
+      displayName: body?.display_name ?? null,
+      description: body?.description ?? null,
+      avatarUrl: body?.avatar_url ?? null,
+    });
+    debugLog('agent-cli', 'profile.update', { actingAgentId, keys: Object.keys(body || {}) });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'profile update failed' } };
+  }
+}
+
+export async function handleAttachmentUpload(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  if (!body?.data_base64) return { status: 400, body: { error: 'data_base64 is required' } };
+  try {
+    const data = await api.uploadAgentAttachment({
+      actingAgentId,
+      filename: body?.filename || 'attachment.bin',
+      contentType: body?.content_type || 'application/octet-stream',
+      dataBase64: body.data_base64,
+    });
+    debugLog('agent-cli', 'attachment.upload', {
+      actingAgentId,
+      asset_id: data?.data?.asset_id,
+      bytes: data?.data?.size_bytes,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'attachment upload failed' } };
+  }
+}
+
+export async function handleProfileAvatarUpload(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  if (!body?.data_base64) return { status: 400, body: { error: 'data_base64 is required' } };
+  if (!body?.content_type || !String(body.content_type).startsWith('image/')) {
+    return { status: 400, body: { error: 'content_type must be image/*' } };
+  }
+  try {
+    const data = await api.uploadAgentAvatar({
+      actingAgentId,
+      filename: body?.filename || 'avatar.bin',
+      contentType: body.content_type,
+      dataBase64: body.data_base64,
+    });
+    debugLog('agent-cli', 'avatar.upload', { actingAgentId, url: data?.url });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'avatar upload failed' } };
+  }
+}
+
+export async function handleAttachmentView(req, query, ctx) {
+  const actingAgentId = getActingAgentId(req, query);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  const assetId = query?.asset_id;
+  if (!assetId) return { status: 400, body: { error: 'asset_id is required' } };
+  try {
+    const data = await api.viewAgentAttachment({ actingAgentId, assetId });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'attachment view failed' } };
+  }
+}
+
+export async function handleGroupCreate(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  const name = String(body?.name || '').trim();
+  if (!name) return { status: 400, body: { error: 'name is required' } };
+  try {
+    const data = await api.createAgentGroup({
+      actingAgentId,
+      name,
+      description: body?.description || null,
+      memberAgentIds: Array.isArray(body?.member_agent_ids) ? body.member_agent_ids : [],
+    });
+    invalidateServerInfoCache(actingAgentId);
+    debugLog('agent-cli', 'group.create', {
+      actingAgentId,
+      conversationId: data?.conversation?.id,
+      members: data?.member_agent_ids,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'group create failed' } };
+  }
+}
+
+export async function handleGroupMembersAdd(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  let conversationId = body?.conversation_id || null;
+  if (!conversationId && body?.target) {
+    const resolved = await resolveTarget(actingAgentId, String(body.target));
+    if (resolved.error) return { status: 404, body: { error: resolved.error } };
+    conversationId = resolved.conversationId;
+  }
+  if (!conversationId) return { status: 400, body: { error: 'target or conversation_id is required' } };
+  const agentIds = Array.isArray(body?.agent_ids) ? body.agent_ids : [];
+  if (agentIds.length === 0) return { status: 400, body: { error: 'agent_ids must be non-empty' } };
+  try {
+    const data = await api.addAgentGroupMembers({
+      actingAgentId, conversationId, agentIds,
+    });
+    invalidateServerInfoCache(actingAgentId);
+    debugLog('agent-cli', 'group.members.add', {
+      actingAgentId, conversationId, agentIds,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'add failed' } };
+  }
+}
+
+export async function handleGroupMembersRemove(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  let conversationId = body?.conversation_id || null;
+  if (!conversationId && body?.target) {
+    const resolved = await resolveTarget(actingAgentId, String(body.target));
+    if (resolved.error) return { status: 404, body: { error: resolved.error } };
+    conversationId = resolved.conversationId;
+  }
+  if (!conversationId) return { status: 400, body: { error: 'target or conversation_id is required' } };
+  const agentId = body?.agent_id;
+  if (!agentId) return { status: 400, body: { error: 'agent_id is required' } };
+  try {
+    const data = await api.removeAgentGroupMember({
+      actingAgentId, conversationId, agentId,
+    });
+    invalidateServerInfoCache(actingAgentId);
+    debugLog('agent-cli', 'group.members.remove', {
+      actingAgentId, conversationId, agentId,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'remove failed' } };
+  }
+}
+
 export async function handleServerInfo(req, query, ctx) {
   const actingAgentId = getActingAgentId(req, query);
   const v = validateActingAgent(actingAgentId, ctx);

package/src/core/agent-home.mjs

@@ -0,0 +1,85 @@
+/**
+ * Per-agent home directory: ~/.ticlawk/agents/<agent_id>/
+ *
+ * The agent's authoritative workspace. The daemon spawns every runtime
+ * with this as cwd; the agent's MEMORY.md, notes/, and any artifacts
+ * it produces live here. No project binding — one MEMORY.md per agent,
+ * lives in cwd, agent reads it via `cat MEMORY.md`.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { AF_HOME } from './config.mjs';
+
+export const AF_AGENTS_DIR = join(AF_HOME, 'agents');
+
+export function getAgentHome(agentId) {
+  if (!agentId) throw new Error('getAgentHome: agentId is required');
+  return join(AF_AGENTS_DIR, String(agentId));
+}
+
+export function getAgentMemoryPath(agentId) {
+  return join(getAgentHome(agentId), 'MEMORY.md');
+}
+
+/**
+ * Make sure the agent home dir exists + has a starter MEMORY.md. Idempotent;
+ * safe to call on every spawn. The daemon does this before driver.spawn()
+ * so cwd is always a real, writable directory.
+ *
+ * Pass `displayName` only when seeding for the first time — existing
+ * MEMORY.md is never overwritten (the agent owns it).
+ */
+export function ensureAgentHome(agentId, { displayName } = {}) {
+  const home = getAgentHome(agentId);
+  mkdirSync(home, { recursive: true });
+  const memoryPath = getAgentMemoryPath(agentId);
+  if (!existsSync(memoryPath)) {
+    writeFileSync(memoryPath, buildInitialMemoryMd({ displayName, home }), 'utf8');
+  }
+  return home;
+}
+
+function buildInitialMemoryMd({ displayName, home }) {
+  const lines = [
+    `# ${displayName || 'Agent'}`,
+    '',
+    '## Role',
+    '<your role definition, evolved over time>',
+    '',
+    '## Workspace',
+    home,
+    '',
+  ];
+  lines.push(
+    '## Key Knowledge',
+    '- (none yet — populate as you learn the user, project, and domain)',
+    '',
+    '## Active Context',
+    '- (none)',
+    '',
+    '## How to update this file',
+    'MEMORY.md is your entry point. Read it at the top of every turn. Add a',
+    '`notes/<topic>.md` for each long-lived knowledge area and link it here.',
+    '',
+  );
+  return lines.join('\n');
+}
+
+/**
+ * Best-effort read of the "## Workspace" line from a MEMORY.md. Useful
+ * if some code wants to know where the agent currently believes it
+ * works (e.g. for UI display). The daemon does NOT use this for spawn
+ * cwd — spawn cwd is always getAgentHome(id).
+ */
+export function readWorkspaceFromMemory(agentId) {
+  const memoryPath = getAgentMemoryPath(agentId);
+  if (!existsSync(memoryPath)) return null;
+  try {
+    const text = readFileSync(memoryPath, 'utf8');
+    const m = text.match(/^##\s+Workspace\s*\n([^\n]+)/m);
+    return m ? m[1].trim() : null;
+  } catch {
+    return null;
+  }
+}

package/src/core/argv.mjs

@@ -29,7 +29,17 @@ export function parseOptionArgs(argv = []) {
       const value = inlineValue !== undefined
         ? inlineValue
         : argv[i + 1] && !argv[i + 1].startsWith('-') ? argv[++i] : true;
-      args[rawKey] = value;
+      // Repeated flags collect into an array so `--attach a --attach b`
+      // surfaces as ['a','b'] to callers that expect repeatable input
+      // (--attach on message send, --member on group create, etc).
+      // First occurrence stays scalar so single-value callers don't
+      // have to learn array-or-string.
+      if (Object.prototype.hasOwnProperty.call(args, rawKey)) {
+        const existing = args[rawKey];
+        args[rawKey] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+      } else {
+        args[rawKey] = value;
+      }
       continue;
     }
     args._.push(arg);