ticlawk 0.1.15-dev.6 → 0.1.16-dev.1

package/src/cli/agent-commands.mjs

@@ -0,0 +1,290 @@
+/**
+ * Agent-facing CLI subcommands.
+ *
+ * These run inside a runtime (Codex / Claude Code / etc.) and post to
+ * the local daemon at TICLAWK_RUNTIME_DAEMON_URL (default
+ * http://127.0.0.1:8741). The daemon validates the caller's
+ * TICLAWK_RUNTIME_AGENT_ID against active bindings before forwarding to
+ * the ticlawk backend.
+ *
+ * Commands:
+ *   ticlawk message send --target <t> [--seen-up-to-seq N] [--reply-to <msg>]
+ *   ticlawk message read --target <t> [--around <msg>] [--limit N]
+ *   ticlawk task claim --message-id <id> [--lease-seconds N]
+ *   ticlawk task update --task-id <id> --status <s>
+ *   ticlawk task list [--target <t>]
+ *   ticlawk group members --target <t>
+ *   ticlawk server info [--refresh]
+ *
+ * `ticlawk message send` reads the message body from stdin so heredocs
+ * work cleanly (matching the Slock convention).
+ */
+
+import { request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+
+function getDaemonUrl() {
+  return process.env.TICLAWK_RUNTIME_DAEMON_URL || 'http://127.0.0.1:8741';
+}
+
+function requireAgentEnv() {
+  const agentId = String(process.env.TICLAWK_RUNTIME_AGENT_ID || '').trim();
+  if (!agentId) {
+    console.error('TICLAWK_RUNTIME_AGENT_ID is required (must be set by the daemon when spawning the runtime).');
+    console.error('If you are seeing this outside an agent runtime, this command is not for you.');
+    process.exit(2);
+  }
+  return {
+    agentId,
+    hostId: String(process.env.TICLAWK_RUNTIME_HOST_ID || '').trim() || null,
+    sessionId: String(process.env.TICLAWK_RUNTIME_SESSION_ID || '').trim() || null,
+  };
+}
+
+function commonHeaders(env) {
+  const headers = {
+    'Content-Type': 'application/json',
+    'X-Ticlawk-Acting-Agent-Id': env.agentId,
+  };
+  if (env.hostId) headers['X-Ticlawk-Runtime-Host-Id'] = env.hostId;
+  if (env.sessionId) headers['X-Ticlawk-Runtime-Session-Id'] = env.sessionId;
+  return headers;
+}
+
+function daemonRequest({ method, path, headers, body }) {
+  const url = new URL(path, getDaemonUrl());
+  const isHttps = url.protocol === 'https:';
+  const requestFn = isHttps ? httpsRequest : httpRequest;
+  const payload = body == null ? null : (typeof body === 'string' ? body : JSON.stringify(body));
+  return new Promise((resolve, reject) => {
+    const req = requestFn({
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: `${url.pathname}${url.search}`,
+      method,
+      headers: {
+        ...headers,
+        ...(payload != null ? { 'Content-Length': Buffer.byteLength(payload) } : {}),
+      },
+    }, (res) => {
+      let text = '';
+      res.on('data', (chunk) => { text += chunk; });
+      res.on('end', () => {
+        let parsed = null;
+        if (text) {
+          try { parsed = JSON.parse(text); } catch { parsed = null; }
+        }
+        resolve({ statusCode: res.statusCode || 0, body: parsed, raw: text });
+      });
+    });
+    req.on('error', reject);
+    if (payload != null) req.write(payload);
+    req.end();
+  });
+}
+
+async function readStdin() {
+  if (process.stdin.isTTY) return '';
+  let buf = '';
+  for await (const chunk of process.stdin) buf += chunk;
+  return buf;
+}
+
+function getArg(args, name) {
+  return args[name] != null ? String(args[name]) : null;
+}
+
+function getNumberArg(args, name) {
+  const v = args[name];
+  if (v == null) return null;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : null;
+}
+
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+
+function exitFromStatus(statusCode, errorBody) {
+  if (statusCode >= 200 && statusCode < 300) return 0;
+  if (statusCode === 409) {
+    if (errorBody) printJson(errorBody);
+    return 1;
+  }
+  if (errorBody) printJson(errorBody);
+  return 1;
+}
+
+export async function runMessageSendCommand(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('message body is required on stdin');
+    console.error('Example:');
+    console.error("  echo \"hello\" | ticlawk message send --target dm:@alice");
+    console.error("  ticlawk message send --target \"#frontend\" <<'EOF'");
+    console.error('  ...message...');
+    console.error('  EOF');
+    return 2;
+  }
+  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'),
+  };
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/message/send',
+    headers: commonHeaders(env),
+    body,
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode, null);
+}
+
+export async function runMessageReadCommand(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 around = getArg(args, 'around');
+  if (around) params.set('around_message_id', around);
+  const beforeSeq = getArg(args, 'before-seq');
+  if (beforeSeq) params.set('before_seq', beforeSeq);
+  const limit = getArg(args, 'limit');
+  if (limit) params.set('limit', limit);
+
+  const res = await daemonRequest({
+    method: 'GET',
+    path: `/agent/message/read?${params}`,
+    headers: commonHeaders(env),
+  });
+  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');
+    return 2;
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/task/claim',
+    headers: commonHeaders(env),
+    body: {
+      source_message_id: messageId,
+      lease_seconds: getNumberArg(args, 'lease-seconds'),
+    },
+  });
+  printJson(res.body);
+  if (res.statusCode === 409) {
+    console.error(`task already claimed by another agent`);
+    return 1;
+  }
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runTaskUpdateCommand(args) {
+  const env = requireAgentEnv();
+  const taskId = getArg(args, 'task-id');
+  const status = getArg(args, 'status');
+  if (!taskId || !status) {
+    console.error('--task-id and --status are required');
+    return 2;
+  }
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/task/update',
+    headers: commonHeaders(env),
+    body: { task_id: taskId, status },
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runTaskListCommand(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/task/list?${params}`,
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runGroupMembersCommand(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/group/members?${params}`,
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export async function runServerInfoCommand(args) {
+  const env = requireAgentEnv();
+  const params = new URLSearchParams();
+  if (args.refresh) params.set('refresh', '1');
+  const res = await daemonRequest({
+    method: 'GET',
+    path: `/agent/server/info?${params}`,
+    headers: commonHeaders(env),
+  });
+  printJson(res.body);
+  return exitFromStatus(res.statusCode);
+}
+
+export const AGENT_COMMAND_HELP = {
+  message: `ticlawk message <send|read>
+  ticlawk message send --target "<target>" [--seen-up-to-seq N] [--reply-to <msg-id>]
+    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
+  ticlawk message read --target "<target>" [--around <msg-id>] [--before-seq N] [--limit N]
+`,
+  task: `ticlawk task <claim|update|list>
+  ticlawk task claim --message-id <id> [--lease-seconds N]
+  ticlawk task update --task-id <id> --status <open|claimed|done|canceled>
+  ticlawk task list [--target <target>]
+`,
+  group: `ticlawk group members --target "<target>"
+`,
+  server: `ticlawk server info [--refresh]
+`,
+};

package/src/core/adapter-registry.mjs

@@ -3,48 +3,32 @@ import {
   getTiclawkAuthHelp,
   runTiclawkAuth,
 } from '../adapters/ticlawk/index.mjs';
-import {
-  createTelegramAdapter,
-  getTelegramAuthHelp,
-  runTelegramAuth,
-} from '../adapters/telegram/index.mjs';
 
-const FACTORIES = {
-  ticlawk: createTiclawkAdapter,
-  telegram: createTelegramAdapter,
-};
+/**
+ * Ticlawk has a single adapter: ticlawk itself. The registry shape is kept
+ * so callers can still depend on a stable surface (createAdapter, etc.)
+ * without branching on adapter ids.
+ */
 
-const AUTH_HANDLERS = {
-  ticlawk: {
-    help: getTiclawkAuthHelp,
-    run: runTiclawkAuth,
-  },
-  telegram: {
-    help: getTelegramAuthHelp,
-    run: runTelegramAuth,
-  },
-};
+const ADAPTER_ID = 'ticlawk';
 
 export function createAdapter(adapterId, ctx) {
-  const factory = FACTORIES[adapterId];
-  if (!factory) {
+  if (adapterId !== ADAPTER_ID) {
     throw new Error(`unsupported adapter: ${adapterId}`);
   }
-  return factory(ctx);
+  return createTiclawkAdapter(ctx);
 }
 
 export function getAdapterAuthHelp(adapterId) {
-  const handler = AUTH_HANDLERS[adapterId];
-  if (!handler?.help) {
+  if (adapterId !== ADAPTER_ID) {
     throw new Error(`unsupported adapter: ${adapterId}`);
   }
-  return handler.help();
+  return getTiclawkAuthHelp();
 }
 
 export async function runAdapterAuth(adapterId, rawArgs) {
-  const handler = AUTH_HANDLERS[adapterId];
-  if (!handler?.run) {
+  if (adapterId !== ADAPTER_ID) {
     throw new Error(`unsupported adapter: ${adapterId}`);
   }
-  return handler.run(rawArgs);
+  return runTiclawkAuth(rawArgs);
 }

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

@@ -0,0 +1,291 @@
+/**
+ * Daemon-side handlers for the agent CLI surface.
+ *
+ * The CLI subcommands (`ticlawk message send`, `ticlawk task claim`, ...)
+ * post to the local daemon at 127.0.0.1:8741. The daemon validates the
+ * caller's TICLAWK_RUNTIME_AGENT_ID against the active binding store
+ * and forwards to the ticlawk backend using the connector API key.
+ *
+ * Targets are parsed in the daemon (not on the wire to backend) so the
+ * CLI can speak `#<group>` / `dm:@<user>` / `#<group>:<short-msg-id>`
+ * while backend keeps a flat conversation_id contract.
+ */
+
+import { debugError, debugLog } from './logger.mjs';
+import * as api from '../adapters/ticlawk/api.mjs';
+
+const SERVER_INFO_CACHE_MS = 30 * 1000;
+const serverInfoCacheByAgent = new Map(); // agentId -> { ts, info }
+
+async function getCachedServerInfo(actingAgentId) {
+  const now = Date.now();
+  const cached = serverInfoCacheByAgent.get(actingAgentId);
+  if (cached && now - cached.ts < SERVER_INFO_CACHE_MS) {
+    return cached.info;
+  }
+  const info = await api.getAgentServerInfo({ actingAgentId });
+  serverInfoCacheByAgent.set(actingAgentId, { ts: now, info });
+  return info;
+}
+
+export function invalidateServerInfoCache(actingAgentId = null) {
+  if (actingAgentId) serverInfoCacheByAgent.delete(actingAgentId);
+  else serverInfoCacheByAgent.clear();
+}
+
+/**
+ * Parse a target string into { conversationId, threadRootMsgId } using a
+ * cached server-info lookup. Returns null fields if the target cannot be
+ * resolved; callers should treat that as a 404.
+ *
+ * Target syntax:
+ *   dm:<uuid>             -> conversation_id = <uuid>
+ *   dm:@<handle>          -> find DM conversation whose other member is <handle>
+ *   #<uuid>               -> conversation_id = <uuid>
+ *   #<group-name>         -> find group conversation by name
+ *   <foo>:<short-msg-id>  -> thread under <foo>, root = first message whose
+ *                            id startsWith <short-msg-id>
+ */
+export async function resolveTarget(actingAgentId, target) {
+  if (!target) return { conversationId: null, threadRootMsgId: null, error: 'target is required' };
+
+  // Strip optional thread suffix.
+  let base = target;
+  let threadShort = null;
+  const colonIdx = target.indexOf(':', target.startsWith('dm:') ? 3 : 1);
+  if (colonIdx > 0 && colonIdx < target.length - 1) {
+    threadShort = target.slice(colonIdx + 1);
+    base = target.slice(0, colonIdx);
+  }
+
+  if (/^[0-9a-f-]{36}$/i.test(base)) {
+    return { conversationId: base, threadRootMsgId: threadShort, error: null };
+  }
+  if (base.startsWith('dm:') && /^[0-9a-f-]{36}$/i.test(base.slice(3))) {
+    return { conversationId: base.slice(3), threadRootMsgId: threadShort, error: null };
+  }
+  if (base.startsWith('#') && /^[0-9a-f-]{36}$/i.test(base.slice(1))) {
+    return { conversationId: base.slice(1), threadRootMsgId: threadShort, error: null };
+  }
+
+  const info = await getCachedServerInfo(actingAgentId);
+  const convs = Array.isArray(info?.conversations) ? info.conversations : [];
+
+  if (base.startsWith('dm:@')) {
+    const handle = base.slice(4).toLowerCase();
+    const match = convs.find((c) =>
+      c.type === 'dm' && (String(c.display_name || c.name || '').toLowerCase() === handle)
+    );
+    if (match) return { conversationId: match.id, threadRootMsgId: threadShort, error: null };
+    return { conversationId: null, threadRootMsgId: null, error: `unknown dm target: ${target}` };
+  }
+  if (base.startsWith('#')) {
+    const name = base.slice(1).toLowerCase();
+    const match = convs.find((c) =>
+      c.type === 'group' && (String(c.name || c.display_name || '').toLowerCase() === name)
+    );
+    if (match) return { conversationId: match.id, threadRootMsgId: threadShort, error: null };
+    return { conversationId: null, threadRootMsgId: null, error: `unknown group target: ${target}` };
+  }
+
+  return { conversationId: null, threadRootMsgId: null, error: `invalid target syntax: ${target}` };
+}
+
+function getActingAgentId(req, body = {}) {
+  const fromHeader = req.headers['x-ticlawk-acting-agent-id'];
+  if (typeof fromHeader === 'string' && fromHeader.trim()) return fromHeader.trim();
+  if (typeof body?.acting_as_agent_id === 'string' && body.acting_as_agent_id.trim()) {
+    return body.acting_as_agent_id.trim();
+  }
+  return null;
+}
+
+function getRuntimeHostId(req, body = {}) {
+  const fromHeader = req.headers['x-ticlawk-runtime-host-id'];
+  if (typeof fromHeader === 'string' && fromHeader.trim()) return fromHeader.trim();
+  if (typeof body?.runtime_host_id === 'string' && body.runtime_host_id.trim()) {
+    return body.runtime_host_id.trim();
+  }
+  return null;
+}
+
+function validateActingAgent(actingAgentId, ctx) {
+  if (!actingAgentId) {
+    return { ok: false, status: 400, error: 'TICLAWK_RUNTIME_AGENT_ID required (passed via X-Ticlawk-Acting-Agent-Id or body.acting_as_agent_id)' };
+  }
+  if (typeof ctx.listBindings === 'function') {
+    const local = ctx.listBindings({ adapter: 'ticlawk' }) || [];
+    const match = local.find((b) => b?.id === actingAgentId);
+    if (!match) {
+      return { ok: false, status: 401, error: `agent ${actingAgentId} is not bound on this host` };
+    }
+  }
+  return { ok: true };
+}
+
+export async function handleMessageSend(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;
+  let threadRootMsgId = 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;
+    threadRootMsgId = resolved.threadRootMsgId;
+  }
+  if (!conversationId) {
+    return { status: 400, body: { error: 'target or conversation_id is required' } };
+  }
+
+  try {
+    const data = await api.sendAgentMessage({
+      actingAgentId,
+      conversationId,
+      text,
+      seenUpToSeq: body?.seen_up_to_seq,
+      replyToMessageId: body?.reply_to_message_id || threadRootMsgId || null,
+      runtimeHostId: getRuntimeHostId(req, body),
+    });
+    debugLog('agent-cli', 'send.ok', {
+      actingAgentId,
+      conversationId,
+      messageId: data?.id,
+      seq: data?.seq,
+      bodyChars: text.length,
+    });
+    return { status: 200, body: { ok: true, data } };
+  } catch (err) {
+    debugError('agent-cli', 'send.failed', {
+      actingAgentId,
+      conversationId,
+      error: err?.message || String(err),
+      status: err?.status || null,
+    });
+    return { status: err?.status || 500, body: { error: err?.message || 'send failed', payload: err?.payload || null } };
+  }
+}
+
+export async function handleMessageRead(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) 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.readAgentMessages({
+      actingAgentId,
+      conversationId,
+      aroundMessageId: query?.around_message_id || null,
+      beforeSeq: query?.before_seq != null ? Number(query.before_seq) : null,
+      limit: query?.limit != null ? Number(query.limit) : null,
+    });
+    return { status: 200, body: { data } };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'read 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' } };
+  try {
+    const data = await api.claimAgentTask({
+      actingAgentId,
+      sourceMessageId,
+      leaseSeconds: body?.lease_seconds,
+    });
+    debugLog('agent-cli', 'task.claim', {
+      actingAgentId,
+      sourceMessageId,
+      claimed: data?.claimed,
+    });
+    return { status: data?.claimed === false ? 409 : 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'claim failed' } };
+  }
+}
+
+export async function handleTaskUpdate(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.updateAgentTask({
+      actingAgentId,
+      taskId: body.task_id,
+      status: body.status || null,
+    });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'update failed' } };
+  }
+}
+
+export async function handleTaskList(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.listAgentTasks({ actingAgentId, conversationId });
+    return { status: 200, body: { data } };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'list failed' } };
+  }
+}
+
+export async function handleGroupMembers(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) 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 res = await api.getConversationMembers({ actingAgentId, conversationId });
+    return { status: 200, body: res };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'members lookup failed' } };
+  }
+}
+
+export async function handleServerInfo(req, query, ctx) {
+  const actingAgentId = getActingAgentId(req, query);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  // Bust cache when CLI explicitly asks
+  if (query?.refresh === '1') invalidateServerInfoCache(actingAgentId);
+  try {
+    const info = await getCachedServerInfo(actingAgentId);
+    return { status: 200, body: info };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'server-info failed' } };
+  }
+}

package/src/core/config.mjs

@@ -17,7 +17,6 @@ export const AF_HOME = process.env.TICLAWK_HOME || join(homedir(), '.ticlawk');
 export const AF_CONFIG_PATH = join(AF_HOME, '.config');
 export const AF_LOG_PATH = join(AF_HOME, 'ticlawk.log');
 export const AF_CRASH_LOG_PATH = join(AF_HOME, 'ticlawk-crash.log');
-export const AF_ADAPTER_KEY = 'AF_ADAPTER';
 export const AF_STREAMING_KEY = 'AF_STREAMING';
 export const AF_STREAMING_RUNTIME_KEYS = Object.fromEntries(
   RUNTIME_DEFINITIONS
@@ -31,28 +30,14 @@ export const RUNTIME_EXECUTABLE_CONFIG_KEYS = Object.fromEntries(
     .filter((runtime) => runtime.executableConfigKey)
     .map((runtime) => [runtime.name, runtime.executableConfigKey])
 );
-export const SUPPORTED_ADAPTERS = ['ticlawk', 'telegram'];
 // Public CLI keys stay kebab/dotted for usability; the persisted .config file
 // stores env-style names because systemd/launchd load it directly.
 export const ADAPTER_CONFIG_KEYS = {
-  'telegram.bot-token': 'TELEGRAM_BOT_TOKEN',
   'ticlawk.connector-api-key': TICLAWK_CONNECTOR_API_KEY,
   'ticlawk.api-url': 'TICLAWK_API_URL',
   'ticlawk.connector-ws-url': TICLAWK_CONNECTOR_WS_URL,
 };
 
-export function normalizeAdapterName(value) {
-  const normalized = String(value || '').trim().toLowerCase().replace(/[-\s]+/g, '_');
-  if (!normalized) return null;
-  if (SUPPORTED_ADAPTERS.includes(normalized)) return normalized;
-  return null;
-}
-
-export function getConfiguredAdapter(config = null) {
-  const source = config || loadPersistentConfig();
-  return normalizeAdapterName(source[AF_ADAPTER_KEY]) || 'ticlawk';
-}
-
 export function normalizeAdapterConfigTarget(target) {
   const normalized = String(target || '').trim().toLowerCase();
   const configKey = ADAPTER_CONFIG_KEYS[normalized];