ticlawk 0.1.12-dev.0

package/bin/ticlawk.mjs

@@ -0,0 +1,594 @@
+#!/usr/bin/env node
+
+import { request } from 'node:http';
+import { resolve } from 'node:path';
+import { installProcessDiagnostics } from '../src/core/diagnostics.mjs';
+import {
+  AF_ADAPTER_KEY,
+  getConfiguredAdapter,
+  loadPersistentConfig,
+  getStreamingConfigView,
+  LEGACY_TICLAWK_API_KEY,
+  normalizeAdapterConfigTarget,
+  normalizeAdapterName,
+  normalizeRuntimeConfigTarget,
+  normalizeStreamingTarget,
+  persistConfig,
+  SUPPORTED_ADAPTERS,
+  TICLAWK_CONNECTOR_API_KEY,
+  TICLAWK_CONNECTOR_WS_URL,
+} from '../src/core/config.mjs';
+import { parseOptionArgs } from '../src/core/argv.mjs';
+import {
+  activateProfile,
+  getActiveProfile,
+  listProfiles,
+} from '../src/core/profiles.mjs';
+import { getAdapterAuthHelp, runAdapterAuth } from '../src/core/adapter-registry.mjs';
+import { runTiclawkConnect } from '../src/core/ticlawk-control.mjs';
+import {
+  RUNTIME_DEFINITIONS,
+  getRuntimeDefinition,
+  getRuntimeDisplayName,
+  getRuntimeExecutableDefinitions,
+  normalizeServiceType,
+} from '../src/core/runtime-registry.mjs';
+import { runSelfUpdate, readPkgVersion } from '../src/core/update.mjs';
+import { getUninstallHelp, runSelfUninstall } from '../src/core/uninstall.mjs';
+import { getInstallDaemonHelp, runInstallDaemon } from '../src/core/daemon-install.mjs';
+import { runSetupReadiness } from '../src/core/setup-readiness.mjs';
+
+const TICLAWK_PORT = Number(process.env.FEED_RELAY_PORT || 8741);
+
+function getConfigKeyUsage() {
+  const runtimeKeys = getRuntimeExecutableDefinitions().map((runtime) => runtime.executableCliKey);
+  return ['adapter', 'streaming...', ...runtimeKeys, 'telegram.bot-token', 'ticlawk.connector-api-key', 'ticlawk.api-url', 'ticlawk.connector-ws-url'].join('|');
+}
+
+function getRuntimeConnectUsageLines() {
+  return RUNTIME_DEFINITIONS
+    .filter((runtime) => !runtime.aliases.includes(''))
+    .map((runtime) => {
+      if (runtime.connect?.locator === 'agentId') {
+        return `  ticlawk connect [--adapter <adapter>] --type ${runtime.name} --agent-id <id> [--name <name>] [--runtime-path <path>] [--switch-user]`;
+      }
+      return `  ticlawk connect [--adapter <adapter>] --type ${runtime.name} [--session-id <id>] --workdir <dir> [--name <name>] [--runtime-path <path>] [--switch-user]`;
+    })
+    .join('\n');
+}
+
+function getRuntimeConfigExamples() {
+  return getRuntimeExecutableDefinitions()
+    .map((runtime) => `  ticlawk config set ${runtime.executableCliKey} /path/to/${runtime.name} # advanced/manual`)
+    .join('\n');
+}
+
+function getRuntimeConnectExamples() {
+  return [
+    '  ticlawk connect --adapter telegram --workdir /path/to/project',
+    '  ticlawk connect --adapter telegram --session-id <claude-session-id>',
+    ...RUNTIME_DEFINITIONS
+      .filter((runtime) => !runtime.aliases.includes(''))
+      .slice(0, 4)
+      .map((runtime) => {
+        if (runtime.connect?.locator === 'agentId') {
+          return `  ticlawk connect --adapter telegram --type ${runtime.name} --agent-id main`;
+        }
+        return `  ticlawk connect --adapter telegram --type ${runtime.name} --workdir /path/to/project`;
+      }),
+  ].join('\n');
+}
+
+function getUsageText() {
+  const configKeys = getConfigKeyUsage();
+  return `ticlawk
+
+Usage:
+  ticlawk help
+  ticlawk help <command>
+  ticlawk start
+  ticlawk health
+  ticlawk config
+  ticlawk config get <${configKeys}>
+  ticlawk config set <${configKeys}> <value>
+  ticlawk auth <adapter> [adapter-auth-args...]
+  ticlawk connect [ticlawk] [codex|claude|opencode|openclaw|pi] [runtime args...]
+  ticlawk connect [--adapter <adapter>] [--session-id <id>] --workdir <dir> [--switch-user]
+${getRuntimeConnectUsageLines()}
+  ticlawk profile list
+  ticlawk profile current
+  ticlawk profile use ticlawk:<user-id>
+  ticlawk install-daemon
+  ticlawk update [-y]
+  ticlawk uninstall [-y]
+  ticlawk version
+
+Commands:
+  auth     store adapter-specific auth/setup input locally
+  connect  connect the selected adapter to a local runtime
+  profile  list or switch saved local identities
+  install-daemon  install or refresh the background daemon
+  update   update the npm package and refresh the daemon
+  uninstall  remove service and legacy install files, preserving ~/.ticlawk
+
+Config examples:
+  ticlawk config get adapter
+  ticlawk config set adapter telegram
+  ticlawk config set adapter ticlawk
+  ticlawk config set streaming off                    # turn streaming off for all runtimes
+  ticlawk config set streaming.codex default          # clear the codex-specific override and inherit the global streaming setting
+${getRuntimeConfigExamples()}
+  ticlawk config set telegram.bot-token <bot-token>   # advanced/manual
+  ticlawk config set ticlawk.connector-api-key <key>   # advanced/manual
+  ticlawk config set ticlawk.api-url <api-url>        # advanced/manual
+  ticlawk config set ticlawk.connector-ws-url <url>   # advanced/manual
+
+Examples:
+  ticlawk connect
+  ticlawk connect ticlawk
+  ticlawk connect ticlawk codex
+  ticlawk connect ticlawk openclaw --agent-id main
+  ticlawk auth telegram --bot-token <bot-token>
+${getRuntimeConnectExamples()}
+`;
+}
+
+function getAuthHelp() {
+  return `ticlawk auth
+
+Use \`auth\` to store adapter-specific auth/setup input locally.
+Adapter-specific args live after \`--\` so new adapters can define their own flags
+without changing the top-level CLI.
+
+Examples:
+  ticlawk auth telegram --bot-token <bot-token>
+
+Per-adapter help:
+  ticlawk auth telegram --help
+`;
+}
+
+function getConnectHelp() {
+  return `ticlawk connect
+
+Use \`connect\` to connect the selected adapter to a local runtime.
+For ticlawk, connect starts the QR pairing flow when no local credential exists.
+Run \`ticlawk connect\` from a project directory to auto-detect
+Codex, Claude Code, opencode, and pi, then choose the runtime in ticlawk.
+By default connect records the runtime binary found in your current terminal.
+Use \`--runtime-path <path>\` only when you need to override that discovery.
+
+Examples:
+  ticlawk connect
+  ticlawk connect ticlawk
+  ticlawk connect ticlawk codex
+  ticlawk connect ticlawk openclaw --agent-id main
+${getRuntimeConnectExamples()}
+`;
+}
+
+function printUsage() {
+  console.log(getUsageText());
+}
+
+function printHelp(helpPath, args = {}) {
+  const [head] = helpPath;
+  if (!head) {
+    printUsage();
+    return;
+  }
+  if (head === 'auth') {
+    const adapterValue = helpPath[1] || args._?.[1];
+    if (adapterValue) {
+      console.log(getAdapterAuthHelp(requireAdapter(adapterValue)));
+      return;
+    }
+    console.log(getAuthHelp());
+    return;
+  }
+  if (head === 'connect') {
+    console.log(getConnectHelp());
+    return;
+  }
+  if (head === 'uninstall') {
+    console.log(getUninstallHelp());
+    return;
+  }
+  if (head === 'install-daemon') {
+    console.log(getInstallDaemonHelp());
+    return;
+  }
+  printUsage();
+}
+
+function formatStreamingValue(value, inherited = false) {
+  const text = value ? 'on' : 'off';
+  return inherited ? `default(${text})` : text;
+}
+
+function parseConfigBoolean(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (['1', 'true', 'on', 'yes'].includes(normalized)) return '1';
+  if (['0', 'false', 'off', 'no'].includes(normalized)) return '0';
+  if (normalized === 'default') return null;
+  return undefined;
+}
+
+function printConfigView(config = loadPersistentConfig()) {
+  console.log(`adapter=${getConfiguredAdapter(config)}`);
+  const view = getStreamingConfigView(config);
+  console.log(`streaming=${formatStreamingValue(view.streaming.value, view.streaming.inherited)}`);
+  for (const runtime of RUNTIME_DEFINITIONS) {
+    const key = `streaming.${runtime.name}`;
+    if (!view[key]) continue;
+    console.log(`${key}=${formatStreamingValue(view[key].value, view[key].inherited)}`);
+  }
+  for (const runtime of getRuntimeExecutableDefinitions()) {
+    console.log(`${runtime.executableCliKey}=${config[runtime.executableConfigKey] || ''}`);
+  }
+  console.log(`telegram.bot-token=${config.TELEGRAM_BOT_TOKEN ? 'set' : 'unset'}`);
+  console.log(`ticlawk.connector-api-key=${config[TICLAWK_CONNECTOR_API_KEY] || config[LEGACY_TICLAWK_API_KEY] ? 'set' : 'unset'}`);
+  console.log(`ticlawk.api-url=${config.TICLAWK_API_URL || ''}`);
+  console.log(`ticlawk.connector-ws-url=${config[TICLAWK_CONNECTOR_WS_URL] || ''}`);
+}
+
+function getLocal(path) {
+  return new Promise((resolve, reject) => {
+    const req = request(
+      { host: '127.0.0.1', port: TICLAWK_PORT, path, method: 'GET' },
+      (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          try {
+            resolve({
+              statusCode: res.statusCode || 0,
+              body: data ? JSON.parse(data) : {},
+            });
+          } catch (err) {
+            reject(err);
+          }
+        });
+      }
+    );
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function formatSecretConfigValue(configKey, value) {
+  if (configKey === 'TELEGRAM_BOT_TOKEN' || configKey === TICLAWK_CONNECTOR_API_KEY || configKey === LEGACY_TICLAWK_API_KEY) {
+    return value ? 'set' : 'unset';
+  }
+  return value || '';
+}
+
+function requireAdapter(value) {
+  const adapterId = normalizeAdapterName(value);
+  if (!adapterId) {
+    const supported = SUPPORTED_ADAPTERS.join(', ');
+    console.error(`invalid adapter: ${value || ''} (supported: ${supported})`);
+    process.exit(1);
+  }
+  return adapterId;
+}
+
+function getConnectAdapter(value) {
+  if (value === undefined || value === null || value === '') {
+    return getConfiguredAdapter();
+  }
+  return requireAdapter(value);
+}
+
+function buildConnectPayload(args) {
+  const positionalAdapter = normalizeAdapterName(args._?.[1]) ? args._[1] : null;
+  const positionalRuntime = positionalAdapter ? args._?.[2] : args._?.[1];
+  const serviceType = normalizeServiceType(args.type || positionalRuntime);
+  const explicitWorkdir = args.workdir || args.cwd || args['project-dir'];
+  const workdir = explicitWorkdir || (positionalAdapter ? resolve('.') : null);
+  const hasExplicitAdapter = Boolean(args.adapter || positionalAdapter);
+  const adapter = (!serviceType && !hasExplicitAdapter)
+    ? 'ticlawk'
+    : getConnectAdapter(args.adapter || positionalAdapter);
+  if (!serviceType) {
+    if (adapter === 'ticlawk' && !args.type && !positionalRuntime) {
+      return {
+        adapter,
+        autoRuntime: true,
+        switchUser: Boolean(args['switch-user']),
+        ...(workdir ? { workdir } : {}),
+        ...(args.name ? { name: args.name } : {}),
+      };
+    }
+    console.error(`invalid runtime type: ${args.type || positionalRuntime || ''}`);
+    process.exit(1);
+  }
+
+  const runtimeDefinition = getRuntimeDefinition(serviceType);
+  if (runtimeDefinition?.connect?.locator === 'agentId') {
+    return {
+      adapter,
+      serviceType,
+      agentId: args['agent-id'],
+      ...(workdir ? { workdir } : {}),
+      ...(args['runtime-path'] ? { runtimePath: resolve(args['runtime-path']) } : {}),
+      name: args.name || args['agent-id'],
+      switchUser: Boolean(args['switch-user']),
+    };
+  }
+
+  return {
+    adapter,
+    serviceType,
+    sessionId: args['session-id'],
+    switchUser: Boolean(args['switch-user']),
+    ...(workdir ? { workdir } : {}),
+    ...(args.name ? { name: args.name } : {}),
+    ...(args['runtime-path'] ? { runtimePath: resolve(args['runtime-path']) } : {}),
+  };
+}
+
+function validateConnectPayload(payload) {
+  if (payload.autoRuntime) return;
+  const runtimeDefinition = getRuntimeDefinition(payload.serviceType);
+  if (runtimeDefinition?.connect?.locator === 'agentId' && !payload.agentId) {
+    console.error(`--agent-id is required for ${getRuntimeDisplayName(payload.serviceType)} connect`);
+    process.exit(1);
+  }
+  if (runtimeDefinition?.connect?.locator !== 'agentId' && !payload.sessionId && !payload.workdir) {
+    const runtimeName = getRuntimeDisplayName(payload.serviceType);
+    console.error(`either --session-id or --workdir is required for ${runtimeName} connect`);
+    process.exit(1);
+  }
+}
+
+function printCommandResult(result) {
+  if (result?.body?.help) {
+    console.log(result.body.help);
+    return;
+  }
+  console.log(JSON.stringify(result?.body || {}, null, 2));
+}
+
+function formatProfileIdentity(profile) {
+  const meta = profile.meta || {};
+  const parts = [
+    profile.ref,
+    meta.emailMasked || meta.email_masked || '',
+    meta.phoneMasked || meta.phone_masked || '',
+  ].filter(Boolean);
+  return parts.join('  ');
+}
+
+function parseProfileUseRef(value) {
+  const raw = String(value || '').trim();
+  const [adapter, ...rest] = raw.split(':');
+  const userId = rest.join(':');
+  if (!adapter || !userId) return null;
+  return { adapter, userId };
+}
+
+async function main() {
+  const rawArgv = process.argv.slice(2);
+  const args = parseOptionArgs(rawArgv);
+  const command = args._[0] || 'start';
+
+  if (command === 'help' || args.help || args.h) {
+    const helpPath = command === 'help' ? args._.slice(1) : args._;
+    printHelp(helpPath, args);
+    return;
+  }
+
+  if (command === 'version' || args.version) {
+    console.log(readPkgVersion());
+    return;
+  }
+
+  if (command === 'start') {
+    installProcessDiagnostics();
+    const { startTiclawk } = await import('../ticlawk.mjs');
+    await startTiclawk();
+    return;
+  }
+
+  if (command === 'health') {
+    const res = await getLocal('/health');
+    console.log(JSON.stringify(res.body, null, 2));
+    process.exitCode = res.statusCode >= 400 ? 1 : 0;
+    return;
+  }
+
+  if (command === 'config') {
+    const subcommand = args._[1];
+    const config = loadPersistentConfig();
+    if (!subcommand) {
+      printConfigView(config);
+      return;
+    }
+
+    if (subcommand === 'get') {
+      const key = args._[2];
+      if (key === 'adapter') {
+        console.log(getConfiguredAdapter(config));
+        return;
+      }
+      const adapterTarget = normalizeAdapterConfigTarget(key);
+      if (adapterTarget) {
+        console.log(formatSecretConfigValue(adapterTarget.configKey, config[adapterTarget.configKey]));
+        return;
+      }
+      const runtimeTarget = normalizeRuntimeConfigTarget(key);
+      if (runtimeTarget) {
+        console.log(config[runtimeTarget.configKey] || '');
+        return;
+      }
+      const target = normalizeStreamingTarget(key);
+      if (!target) {
+        console.error(`unknown config key: ${key || ''}`);
+        process.exit(1);
+      }
+      const view = getStreamingConfigView();
+      const current = view[target.key];
+      console.log(formatStreamingValue(current.value, current.inherited));
+      return;
+    }
+
+    if (subcommand === 'set') {
+      const key = args._[2];
+      const rawValue = args._[3];
+      if (key === 'adapter') {
+        if (!rawValue) {
+          console.error('config set adapter requires a value');
+          process.exit(1);
+        }
+        const adapterId = requireAdapter(rawValue);
+        persistConfig({ [AF_ADAPTER_KEY]: adapterId });
+        console.log(`adapter=${adapterId}`);
+        return;
+      }
+      const adapterTarget = normalizeAdapterConfigTarget(key);
+      if (adapterTarget) {
+        if (!rawValue) {
+          console.error(`config set ${key} requires a value`);
+          process.exit(1);
+        }
+        persistConfig({ [adapterTarget.configKey]: rawValue });
+        console.log(`${adapterTarget.key}=${formatSecretConfigValue(adapterTarget.configKey, rawValue)}`);
+        return;
+      }
+      const runtimeTarget = normalizeRuntimeConfigTarget(key);
+      if (runtimeTarget) {
+        if (!rawValue) {
+          console.error(`config set ${key} requires a value`);
+          process.exit(1);
+        }
+        persistConfig({ [runtimeTarget.configKey]: rawValue === 'default' ? '' : rawValue });
+        console.log(`${runtimeTarget.key}=${rawValue === 'default' ? '' : rawValue}`);
+        return;
+      }
+      const target = normalizeStreamingTarget(key);
+      if (!target) {
+        console.error(`unknown config key: ${key || ''}`);
+        process.exit(1);
+      }
+      if (!rawValue) {
+        console.error('config set requires a value');
+        process.exit(1);
+      }
+      const parsedValue = parseConfigBoolean(rawValue);
+      if (parsedValue === undefined) {
+        console.error(`invalid config value: ${rawValue}`);
+        process.exit(1);
+      }
+      persistConfig({ [target.configKey]: parsedValue });
+      const view = getStreamingConfigView(loadPersistentConfig());
+      const currentKey = target.key;
+      const current = view[currentKey];
+      console.log(`${currentKey}=${formatStreamingValue(current.value, current.inherited)}`);
+      return;
+    }
+
+    console.error(`unknown config subcommand: ${subcommand}`);
+    process.exit(1);
+  }
+
+  if (command === 'profile') {
+    const subcommand = args._[1] || 'list';
+    const active = getActiveProfile();
+    if (subcommand === 'current') {
+      console.log(active?.ref || 'none');
+      return;
+    }
+    if (subcommand === 'list') {
+      const profiles = listProfiles();
+      console.log(`Active profile: ${active?.ref || 'none'}`);
+      if (!profiles.length) {
+        console.log('No saved profiles.');
+        return;
+      }
+      for (const profile of profiles) {
+        const marker = active?.ref === profile.ref ? '*' : ' ';
+        console.log(`${marker} ${formatProfileIdentity(profile)}`);
+      }
+      return;
+    }
+    if (subcommand === 'use') {
+      const target = parseProfileUseRef(args._[2]);
+      if (!target) {
+        console.error('profile use requires a profile ref like ticlawk:<user-id>');
+        process.exit(1);
+      }
+      const activated = activateProfile(target.adapter, target.userId);
+      console.log(`Active profile: ${activated.ref}`);
+      console.log('Restart ticlawk for the daemon to use the selected profile.');
+      return;
+    }
+    console.error(`unknown profile subcommand: ${subcommand}`);
+    process.exit(1);
+  }
+
+  if (command === 'update') {
+    await runSelfUpdate(Boolean(args.y || args.yes));
+    return;
+  }
+
+  if (command === 'install-daemon') {
+    if (args.help || args.h) {
+      console.log(getInstallDaemonHelp());
+      return;
+    }
+    await runInstallDaemon();
+    return;
+  }
+
+  if (command === 'setup-readiness') {
+    await runSetupReadiness({ ensureDaemon: Boolean(args['ensure-daemon']) });
+    return;
+  }
+
+  if (command === 'uninstall') {
+    if (args.help || args.h) {
+      console.log(getUninstallHelp());
+      return;
+    }
+    await runSelfUninstall(Boolean(args.y || args.yes));
+    return;
+  }
+
+  if (command === 'auth') {
+    if (args.help || args.h) {
+      printHelp(['auth'], args);
+      return;
+    }
+    const adapterId = requireAdapter(args._[1]);
+    const adapterArgv = rawArgv.slice(2);
+    const res = await runAdapterAuth(adapterId, adapterArgv);
+    printCommandResult(res);
+    process.exitCode = res.statusCode >= 400 ? 1 : 0;
+    return;
+  }
+
+  if (command === 'connect') {
+    if (args.help || args.h) {
+      console.log(getConnectHelp());
+      return;
+    }
+    const payload = buildConnectPayload(args);
+    validateConnectPayload(payload);
+    const res = await runTiclawkConnect(payload);
+    printCommandResult(res);
+    if (res.statusCode < 400) {
+      await runSetupReadiness({ ensureDaemon: true });
+    }
+    process.exitCode = res.statusCode >= 400 ? 1 : 0;
+    return;
+  }
+
+  printUsage();
+  process.exit(1);
+}
+
+main().catch((err) => {
+  console.error(err.message || String(err));
+  process.exit(1);
+});

package/cc-watcher.mjs

@@ -0,0 +1,3 @@
+// Compatibility entry for older deep imports.
+// Runtime code imports the implementation from src/runtimes/claude-code/.
+export * from './src/runtimes/claude-code/transcripts.mjs';

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "ticlawk",
+  "version": "0.1.12-dev.0",
+  "description": "Connect local agent harnesses to Ticlawk, Telegram, and other mobile clients.",
+  "type": "module",
+  "main": "ticlawk.mjs",
+  "exports": {
+    ".": "./ticlawk.mjs",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "ticlawk": "bin/ticlawk.mjs",
+    "agent-freeway": "bin/agent-freeway.mjs"
+  },
+  "files": [
+    "assets/",
+    "bin/",
+    "scripts/postinstall.mjs",
+    "src/",
+    "cc-watcher.mjs",
+    "ticlawk.mjs",
+    "agent-freeway.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.mjs",
+    "start": "node ./bin/ticlawk.mjs start",
+    "health": "node ./bin/ticlawk.mjs health",
+    "dev": "echo 'Configure ~/.ticlawk/.config, then: npm run start'",
+    "generate:usage-docs": "node scripts/generate-usage-docs.mjs",
+    "verify:public-package": "bash scripts/verify-ticlawk-public.sh"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/darthjaja6/ticlawk.git"
+  },
+  "keywords": [
+    "ticlawk",
+    "claude-code",
+    "claude",
+    "anthropic",
+    "openclaw",
+    "codex",
+    "agent",
+    "ai-agent",
+    "telegram",
+    "telegram-bot",
+    "chatops",
+    "remote-agent",
+    "mobile",
+    "bridge",
+    "gateway"
+  ],
+  "author": "darthjaja6",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/darthjaja6/ticlawk/issues"
+  },
+  "homepage": "https://github.com/darthjaja6/ticlawk#readme",
+  "dependencies": {
+    "dotenv": "^17.4.2",
+    "qrcode-terminal": "^0.12.0",
+    "ws": "^8.20.0"
+  }
+}