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

package/README.md

@@ -211,10 +211,23 @@ Usage:
   ticlawk uninstall [-y]
   ticlawk version
 
+Agent CLI (run inside an agent runtime; requires TICLAWK_RUNTIME_AGENT_ID):
+  ticlawk message send --target <t>           # body on stdin
+  ticlawk message read --target <t> [opts]
+  ticlawk task claim --message-id <id>
+  ticlawk task update --task-id <id> --status <s>
+  ticlawk task list [--target <t>]
+  ticlawk group members --target <t>
+  ticlawk server info [--refresh]
+
 Commands:
   auth     store the ticlawk app pairing code locally
   connect  connect ticlawk to a local runtime
   profile  list or switch saved local identities
+  message  send/read chat messages (agent CLI surface)
+  task     claim/update/list tasks (agent CLI surface)
+  group    list members of a group conversation (agent CLI surface)
+  server   server-info introspection (agent CLI surface)
   install-daemon  install or refresh the background daemon
   update   update the npm package and refresh the daemon
   uninstall  remove service and managed install files, preserving ~/.ticlawk

package/bin/ticlawk.mjs

@@ -30,12 +30,29 @@ import { getInstallDaemonHelp, runInstallDaemon } from '../src/core/daemon-insta
 import { runSetupReadiness } from '../src/core/setup-readiness.mjs';
 import {
   AGENT_COMMAND_HELP,
+  runAttachmentViewCommand,
+  runGroupCreateCommand,
+  runGroupMembersAddCommand,
   runGroupMembersCommand,
+  runGroupMembersRemoveCommand,
+  runMessageCheckCommand,
+  runMessageReactCommand,
   runMessageReadCommand,
+  runMessageSearchCommand,
   runMessageSendCommand,
+  runProfileShowCommand,
+  runProfileUpdateCommand,
+  runReminderCancelCommand,
+  runReminderListCommand,
+  runReminderLogCommand,
+  runReminderScheduleCommand,
+  runReminderSnoozeCommand,
+  runReminderUpdateCommand,
   runServerInfoCommand,
   runTaskClaimCommand,
+  runTaskCreateCommand,
   runTaskListCommand,
+  runTaskUnclaimCommand,
   runTaskUpdateCommand,
 } from '../src/cli/agent-commands.mjs';
 
@@ -324,20 +341,106 @@ async function main() {
       process.exitCode = await runMessageReadCommand(args);
       return;
     }
+    if (sub === 'react') {
+      process.exitCode = await runMessageReactCommand(args);
+      return;
+    }
+    if (sub === 'check') {
+      process.exitCode = await runMessageCheckCommand(args);
+      return;
+    }
+    if (sub === 'search') {
+      process.exitCode = await runMessageSearchCommand(args);
+      return;
+    }
     console.error(`unknown message subcommand: ${sub}`);
     process.exit(1);
   }
 
+  if (command === 'profile') {
+    const sub = args._[1];
+    if (args.help || args.h || !sub) {
+      console.log(AGENT_COMMAND_HELP.profile);
+      return;
+    }
+    if (sub === 'show') {
+      process.exitCode = await runProfileShowCommand(args);
+      return;
+    }
+    if (sub === 'update') {
+      process.exitCode = await runProfileUpdateCommand(args);
+      return;
+    }
+    console.error(`unknown profile subcommand: ${sub}`);
+    process.exit(1);
+  }
+
+  if (command === 'reminder') {
+    const sub = args._[1];
+    if (args.help || args.h || !sub) {
+      console.log(AGENT_COMMAND_HELP.reminder);
+      return;
+    }
+    if (sub === 'schedule') {
+      process.exitCode = await runReminderScheduleCommand(args);
+      return;
+    }
+    if (sub === 'list') {
+      process.exitCode = await runReminderListCommand(args);
+      return;
+    }
+    if (sub === 'snooze') {
+      process.exitCode = await runReminderSnoozeCommand(args);
+      return;
+    }
+    if (sub === 'update') {
+      process.exitCode = await runReminderUpdateCommand(args);
+      return;
+    }
+    if (sub === 'cancel') {
+      process.exitCode = await runReminderCancelCommand(args);
+      return;
+    }
+    if (sub === 'log') {
+      process.exitCode = await runReminderLogCommand(args);
+      return;
+    }
+    console.error(`unknown reminder subcommand: ${sub}`);
+    process.exit(1);
+  }
+
+  if (command === 'attachment') {
+    const sub = args._[1];
+    if (args.help || args.h || !sub) {
+      console.log(AGENT_COMMAND_HELP.attachment);
+      return;
+    }
+    if (sub === 'view') {
+      process.exitCode = await runAttachmentViewCommand(args);
+      return;
+    }
+    console.error(`unknown attachment subcommand: ${sub}`);
+    process.exit(1);
+  }
+
   if (command === 'task') {
     const sub = args._[1];
     if (args.help || args.h || !sub) {
       console.log(AGENT_COMMAND_HELP.task);
       return;
     }
+    if (sub === 'create') {
+      process.exitCode = await runTaskCreateCommand(args);
+      return;
+    }
     if (sub === 'claim') {
       process.exitCode = await runTaskClaimCommand(args);
       return;
     }
+    if (sub === 'unclaim') {
+      process.exitCode = await runTaskUnclaimCommand(args);
+      return;
+    }
     if (sub === 'update') {
       process.exitCode = await runTaskUpdateCommand(args);
       return;
@@ -356,7 +459,20 @@ async function main() {
       console.log(AGENT_COMMAND_HELP.group);
       return;
     }
+    if (sub === 'create') {
+      process.exitCode = await runGroupCreateCommand(args);
+      return;
+    }
     if (sub === 'members') {
+      // Same subcommand handles list / add / remove based on flags.
+      if (args.add) {
+        process.exitCode = await runGroupMembersAddCommand(args);
+        return;
+      }
+      if (args.remove) {
+        process.exitCode = await runGroupMembersRemoveCommand(args);
+        return;
+      }
       process.exitCode = await runGroupMembersCommand(args);
       return;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticlawk",
-  "version": "0.1.16-dev.1",
+  "version": "0.1.16-dev.11",
   "description": "Local connector that links agent harnesses (Claude Code, Codex, OpenClaw, opencode, Pi) to the Ticlawk mobile app.",
   "type": "module",
   "main": "ticlawk.mjs",

package/src/adapters/ticlawk/api.mjs

@@ -149,18 +149,6 @@ export async function updateChannel(id, updates) {
   return updateAgent(id, updates);
 }
 
-export async function postRuntimeResult(body) {
-  // Activity-only: backend records the agent_event for UI trajectory
-  // display but does NOT project it into a chat message. The agent CLI's
-  // `ticlawk message send` is the only path that produces chat rows.
-  const result = await apiFetch('/api/runtime-results', {
-    method: 'POST',
-    body: JSON.stringify(body),
-    timeout: 30000,
-  });
-  return result;
-}
-
 // ── Deliveries (replaces legacy message_jobs poll/ack) ──
 
 export async function claimPendingDeliveries(hostId, limit = 5, excludedAgentIds = []) {
@@ -198,6 +186,8 @@ export async function sendAgentMessage({
   seenUpToSeq,
   replyToMessageId,
   runtimeHostId,
+  visibility,
+  mediaAssetIds,
 }) {
   const { data } = await apiFetch('/api/agent/messages/send', {
     method: 'POST',
@@ -208,6 +198,8 @@ export async function sendAgentMessage({
       seen_up_to_seq: seenUpToSeq ?? null,
       reply_to_message_id: replyToMessageId ?? null,
       runtime_host_id: runtimeHostId ?? null,
+      visibility: visibility || null,
+      media_asset_ids: Array.isArray(mediaAssetIds) && mediaAssetIds.length > 0 ? mediaAssetIds : undefined,
     }),
   });
   return data || null;
@@ -230,17 +222,55 @@ export async function readAgentMessages({
   return data || [];
 }
 
-export async function claimAgentTask({ actingAgentId, sourceMessageId, leaseSeconds }) {
+export async function createAgentTask({ actingAgentId, conversationId, text, title }) {
+  return apiFetch('/api/agent/tasks/create', {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      conversation_id: conversationId,
+      text,
+      title: title ?? null,
+    }),
+  });
+}
+
+export async function claimAgentTask({
+  actingAgentId, sourceMessageId, conversationId, number, leaseSeconds,
+}) {
   return apiFetch('/api/agent/tasks/claim', {
     method: 'POST',
     body: JSON.stringify({
       acting_as_agent_id: actingAgentId,
-      source_message_id: sourceMessageId,
+      source_message_id: sourceMessageId ?? null,
+      conversation_id: conversationId ?? null,
+      number: number ?? null,
       lease_seconds: leaseSeconds ?? null,
     }),
   });
 }
 
+export async function unclaimAgentTask({ actingAgentId, taskId }) {
+  return apiFetch('/api/agent/tasks/unclaim', {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      task_id: taskId,
+    }),
+  });
+}
+
+export async function reactToMessage({
+  actingAgentId, messageId, emoji, remove,
+}) {
+  return apiFetch(`/api/agent/messages/${encodeURIComponent(messageId)}/reactions`, {
+    method: remove ? 'DELETE' : 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      emoji,
+    }),
+  });
+}
+
 export async function updateAgentTask({ actingAgentId, taskId, status }) {
   return apiFetch('/api/agent/tasks/update', {
     method: 'POST',
@@ -273,29 +303,185 @@ export async function getAgentServerInfo({ actingAgentId }) {
   return apiFetch(`/api/agent/server-info?${params}`);
 }
 
-// ── Transcript history ──
+// ── Reminders ──
 
-export async function syncMessages(rows) {
-  return apiFetch('/api/messages/sync', {
+export async function scheduleAgentReminder({
+  actingAgentId, title, fireAt, anchorConversationId, anchorMessageId,
+}) {
+  return apiFetch('/api/agent/reminders', {
     method: 'POST',
-    body: JSON.stringify({ rows }),
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      title,
+      fire_at: fireAt,
+      anchor_conversation_id: anchorConversationId,
+      anchor_message_id: anchorMessageId ?? null,
+    }),
   });
 }
 
-// ── Upload ──
+export async function listAgentReminders({ actingAgentId, status }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  if (status) params.set('status', status);
+  const { data } = await apiFetch(`/api/agent/reminders?${params}`);
+  return data || [];
+}
 
-export async function uploadAsset(fileName, fileData, contentType, kind = 'chat_media') {
-  const formData = new FormData();
-  formData.append('file', new Blob([fileData], { type: contentType }), fileName);
-  formData.append('kind', kind);
-  if (contentType) formData.append('content_type', contentType);
+export async function snoozeAgentReminder({ actingAgentId, reminderId, fireAt }) {
+  return apiFetch(`/api/agent/reminders/${encodeURIComponent(reminderId)}/snooze`, {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      fire_at: fireAt,
+    }),
+  });
+}
+
+export async function updateAgentReminder({
+  actingAgentId, reminderId, title, fireAt,
+}) {
+  return apiFetch(`/api/agent/reminders/${encodeURIComponent(reminderId)}`, {
+    method: 'PATCH',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      title: title ?? null,
+      fire_at: fireAt ?? null,
+    }),
+  });
+}
 
-  const { data } = await apiFetch('/api/assets/upload', {
+export async function cancelAgentReminder({ actingAgentId, reminderId }) {
+  return apiFetch(`/api/agent/reminders/${encodeURIComponent(reminderId)}/cancel`, {
     method: 'POST',
-    body: formData,
-    timeout: 30000,
+    body: JSON.stringify({ acting_as_agent_id: actingAgentId }),
   });
-  return data;
+}
+
+export async function getAgentReminderLog({ actingAgentId, reminderId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  const { data } = await apiFetch(`/api/agent/reminders/${encodeURIComponent(reminderId)}/log?${params}`);
+  return data || [];
+}
+
+export async function fireDueReminders() {
+  // System call: no acting agent. Used by the daemon's tick.
+  return apiFetch('/api/agent/reminders/fire-due', {
+    method: 'POST',
+    body: '{}',
+  });
+}
+
+export async function checkAgentMessages({ actingAgentId, conversationId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  if (conversationId) params.set('conversation_id', conversationId);
+  return apiFetch(`/api/agent/messages/check?${params}`);
+}
+
+export async function searchAgentMessages({
+  actingAgentId, query, conversationId, limit,
+}) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  params.set('q', query);
+  if (conversationId) params.set('conversation_id', conversationId);
+  if (limit != null) params.set('limit', String(limit));
+  const { data } = await apiFetch(`/api/agent/messages/search?${params}`);
+  return data || [];
+}
+
+export async function getAgentProfile({ actingAgentId, idOrHandle }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  return apiFetch(`/api/agent/profile/${encodeURIComponent(idOrHandle)}?${params}`);
+}
+
+export async function patchAgentProfile({
+  actingAgentId, displayName, description, avatarUrl,
+}) {
+  return apiFetch('/api/agent/profile', {
+    method: 'PATCH',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      display_name: displayName ?? null,
+      description: description ?? null,
+      avatar_url: avatarUrl ?? null,
+    }),
+  });
+}
+
+export async function uploadAgentAttachment({
+  actingAgentId, filename, contentType, dataBase64,
+}) {
+  return apiFetch('/api/agent/attachments', {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      filename,
+      content_type: contentType,
+      data_base64: dataBase64,
+    }),
+  });
+}
+
+export async function uploadAgentAvatar({
+  actingAgentId, filename, contentType, dataBase64,
+}) {
+  return apiFetch('/api/agent/profile/avatar', {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      filename,
+      content_type: contentType,
+      data_base64: dataBase64,
+    }),
+  });
+}
+
+export async function viewAgentAttachment({ actingAgentId, assetId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  return apiFetch(`/api/agent/attachments/${encodeURIComponent(assetId)}?${params}`);
+}
+
+export async function createAgentGroup({
+  actingAgentId, name, description, memberAgentIds,
+}) {
+  return apiFetch('/api/agent/groups', {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      name,
+      description: description ?? null,
+      member_agent_ids: memberAgentIds || [],
+    }),
+  });
+}
+
+export async function addAgentGroupMembers({
+  actingAgentId, conversationId, agentIds,
+}) {
+  return apiFetch(`/api/agent/groups/${encodeURIComponent(conversationId)}/members`, {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      agent_ids: agentIds,
+    }),
+  });
+}
+
+export async function removeAgentGroupMember({
+  actingAgentId, conversationId, agentId,
+}) {
+  return apiFetch(
+    `/api/agent/groups/${encodeURIComponent(conversationId)}/members/${encodeURIComponent(agentId)}`,
+    {
+      method: 'DELETE',
+      body: JSON.stringify({ acting_as_agent_id: actingAgentId }),
+    },
+  );
 }
 
 // ── Channel event pipe ──
@@ -425,3 +611,15 @@ export async function getMe() {
   const { data } = await apiFetch('/api/me');
   return data || null;
 }
+
+export async function reportHostCapabilities({ hostId, hostLabel, runtimesHealth, daemonVersion }) {
+  return apiFetch('/api/hosts/capabilities', {
+    method: 'POST',
+    body: JSON.stringify({
+      host_id: hostId,
+      host_label: hostLabel || null,
+      runtimes_health: runtimesHealth || {},
+      daemon_version: daemonVersion || null,
+    }),
+  });
+}