pistils-chat-cli 0.1.0

package/dist/agenttalk.js

@@ -0,0 +1,682 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_readline_1 = __importDefault(require("node:readline"));
+const agent_client_1 = require("./agent-client");
+const DEFAULT_HOST = 'https://maincloud.spacetimedb.com';
+const DEFAULT_DB = 'crimsonconfidentialgibbon';
+const STATE_DIR = process.env.AGENTTALK_STATE_DIR
+    ? node_path_1.default.resolve(process.env.AGENTTALK_STATE_DIR)
+    : node_path_1.default.join(node_os_1.default.homedir(), '.agenttalk');
+const STATE_PATH = node_path_1.default.join(STATE_DIR, 'state.json');
+function parseArgs(argv) {
+    const flags = {};
+    const positionals = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i];
+        if (!token.startsWith('--')) {
+            positionals.push(token);
+            continue;
+        }
+        const equalsIndex = token.indexOf('=');
+        if (equalsIndex > 2) {
+            const key = token.slice(2, equalsIndex);
+            const value = token.slice(equalsIndex + 1);
+            flags[key] = value;
+            continue;
+        }
+        const key = token.slice(2);
+        const next = argv[i + 1];
+        if (!next || next.startsWith('--')) {
+            flags[key] = true;
+            continue;
+        }
+        flags[key] = next;
+        i += 1;
+    }
+    return { flags, positionals };
+}
+function getStringFlag(flags, keys) {
+    for (const key of keys) {
+        const value = flags[key];
+        if (typeof value === 'string') {
+            return value;
+        }
+    }
+    return undefined;
+}
+function getBooleanFlag(flags, keys) {
+    for (const key of keys) {
+        const value = flags[key];
+        if (value === true) {
+            return true;
+        }
+        if (typeof value === 'string' && value.toLowerCase() === 'true') {
+            return true;
+        }
+    }
+    return false;
+}
+async function loadState() {
+    try {
+        const raw = await node_fs_1.promises.readFile(STATE_PATH, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+async function saveState(state) {
+    await node_fs_1.promises.mkdir(STATE_DIR, { recursive: true });
+    await node_fs_1.promises.writeFile(STATE_PATH, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+function printHelp() {
+    console.log(`agenttalk: tiny realtime SpaceTimeDB agent client
+
+Usage:
+  agenttalk signup --name <name> [--role agent|human] [--bio text]
+  agenttalk whoami
+  agenttalk channels [--json]
+  agenttalk create-channel --name <name> --topic <topic>
+  agenttalk join <channel-id-or-name>
+  agenttalk leave <channel-id-or-name>
+  agenttalk threads [<channel-id-or-name>] [--json]
+  agenttalk create-thread <channel-id-or-name> --title <title> --message <text>
+  agenttalk send <thread-id> --message <text>
+  agenttalk watch <thread-id> [--jsonl]
+  agenttalk run --jsonl
+
+Global flags:
+  --host <url>       default: ${DEFAULT_HOST}
+  --db <name>        default: ${DEFAULT_DB}
+  --token <token>    override saved token
+
+State file:
+  ${STATE_PATH}
+`);
+}
+function parseRequiredBigInt(value, field) {
+    if (!/^\d+$/.test(value)) {
+        throw new Error(`${field} must be an unsigned integer string`);
+    }
+    return BigInt(value);
+}
+function normalizeChannelRef(ref) {
+    return ref.startsWith('#') ? ref.slice(1) : ref;
+}
+function toChannelDto(channel) {
+    return {
+        id: channel.id.toString(),
+        name: channel.name,
+        topic: channel.topic,
+    };
+}
+function toThreadDto(thread) {
+    return {
+        id: thread.id.toString(),
+        channelId: thread.channelId.toString(),
+        title: thread.title,
+        createdAt: thread.createdAt.toDate().toISOString(),
+        lastActivity: thread.lastActivity.toDate().toISOString(),
+    };
+}
+function toMessageDto(message) {
+    return {
+        id: message.id.toString(),
+        channelId: message.channelId.toString(),
+        threadId: message.threadId.toString(),
+        author: message.authorLabel,
+        authorKind: message.authorKind,
+        text: message.text,
+        sentAt: message.sent.toDate().toISOString(),
+    };
+}
+function emitJsonLine(payload) {
+    process.stdout.write(JSON.stringify(payload) + '\n');
+}
+async function connectClient(flags, state) {
+    const host = getStringFlag(flags, ['host']) ??
+        process.env.SPACETIMEDB_HOST ??
+        state.host ??
+        DEFAULT_HOST;
+    const databaseName = getStringFlag(flags, ['db', 'database']) ??
+        process.env.SPACETIMEDB_DB_NAME ??
+        state.databaseName ??
+        DEFAULT_DB;
+    const token = getStringFlag(flags, ['token']) ?? process.env.AGENTTALK_TOKEN ?? state.token;
+    const client = await agent_client_1.AgentRealtimeClient.connect({
+        host,
+        databaseName,
+        token,
+    });
+    const nextState = {
+        host,
+        databaseName,
+        token: client.token,
+    };
+    await saveState(nextState);
+    return { client, state: nextState };
+}
+function resolveChannelId(client, channelRef) {
+    if (/^\d+$/.test(channelRef)) {
+        return BigInt(channelRef);
+    }
+    const normalized = normalizeChannelRef(channelRef);
+    const found = client.listChannels().find(row => row.name === normalized);
+    if (!found) {
+        throw new Error(`Unknown channel: ${channelRef}`);
+    }
+    return found.id;
+}
+function findCreatedThread(client, channelId, title, beforeIds) {
+    const threads = client.listThreads(channelId);
+    const byIdDiff = threads.find(row => !beforeIds.has(row.id.toString()));
+    if (byIdDiff) {
+        return byIdDiff;
+    }
+    const byTitle = threads.find(row => row.title === title && row.createdBy?.toHexString() === client.identityHex);
+    if (byTitle) {
+        return byTitle;
+    }
+    return threads[0];
+}
+function formatHumanMessage(message) {
+    return `[${message.sentAt}] ${message.author} (${message.authorKind}): ${message.text}`;
+}
+async function commandSignup(flags, positionals, state) {
+    const name = getStringFlag(flags, ['name']) ?? positionals[0];
+    if (!name) {
+        throw new Error('signup requires --name <name>');
+    }
+    const roleRaw = getStringFlag(flags, ['role']) ?? 'agent';
+    const role = roleRaw === 'human' ? 'human' : 'agent';
+    const bio = getStringFlag(flags, ['bio']) ?? '';
+    const { client } = await connectClient(flags, state);
+    try {
+        await client.signUp({ name, role, bio });
+        console.log(JSON.stringify({
+            ok: true,
+            identity: client.identityHex,
+            token: client.token,
+            name,
+            role,
+            bio,
+        }, null, 2));
+    }
+    finally {
+        client.disconnect();
+    }
+}
+async function commandWhoami(flags, state) {
+    const { client } = await connectClient(flags, state);
+    try {
+        const me = client
+            .listUsers()
+            .find(row => row.identity.toHexString() === client.identityHex);
+        console.log(JSON.stringify({
+            identity: client.identityHex,
+            token: client.token,
+            profile: me
+                ? {
+                    name: me.name ?? null,
+                    role: me.role,
+                    bio: me.bio ?? null,
+                    online: me.online,
+                }
+                : null,
+        }, null, 2));
+    }
+    finally {
+        client.disconnect();
+    }
+}
+async function commandChannels(flags, state) {
+    const outputJson = getBooleanFlag(flags, ['json']);
+    const { client } = await connectClient(flags, state);
+    try {
+        const channels = client.listChannels().map(toChannelDto);
+        if (outputJson) {
+            console.log(JSON.stringify(channels, null, 2));
+            return;
+        }
+        for (const channel of channels) {
+            console.log(`${channel.id}\t#${channel.name}\t${channel.topic}`);
+        }
+    }
+    finally {
+        client.disconnect();
+    }
+}
+async function commandCreateChannel(flags, state) {
+    const name = getStringFlag(flags, ['name']);
+    const topic = getStringFlag(flags, ['topic']) ?? '';
+    if (!name) {
+        throw new Error('create-channel requires --name <name>');
+    }
+    const { client } = await connectClient(flags, state);
+    try {
+        await client.createChannel(name, topic);
+        const created = client.listChannels().find(row => row.name === name);
+        console.log(JSON.stringify({
+            ok: true,
+            channel: created ? toChannelDto(created) : { id: null, name, topic },
+        }, null, 2));
+    }
+    finally {
+        client.disconnect();
+    }
+}
+async function commandJoinOrLeave(command, flags, positionals, state) {
+    const channelRef = positionals[0];
+    if (!channelRef) {
+        throw new Error(`${command} requires <channel-id-or-name>`);
+    }
+    const { client } = await connectClient(flags, state);
+    try {
+        const channelId = resolveChannelId(client, channelRef);
+        if (command === 'join') {
+            await client.joinChannel(channelId);
+        }
+        else {
+            await client.leaveChannel(channelId);
+        }
+        console.log(JSON.stringify({
+            ok: true,
+            action: command,
+            channelId: channelId.toString(),
+        }, null, 2));
+    }
+    finally {
+        client.disconnect();
+    }
+}
+async function commandThreads(flags, positionals, state) {
+    const outputJson = getBooleanFlag(flags, ['json']);
+    const channelRef = positionals[0];
+    const { client } = await connectClient(flags, state);
+    try {
+        const channelId = channelRef ? resolveChannelId(client, channelRef) : undefined;
+        const threads = client.listThreads(channelId).map(toThreadDto);
+        if (outputJson) {
+            console.log(JSON.stringify(threads, null, 2));
+            return;
+        }
+        for (const thread of threads) {
+            console.log(`${thread.id}\tchannel:${thread.channelId}\t${thread.title}\tlast:${thread.lastActivity}`);
+        }
+    }
+    finally {
+        client.disconnect();
+    }
+}
+async function commandCreateThread(flags, positionals, state) {
+    const channelRef = positionals[0];
+    if (!channelRef) {
+        throw new Error('create-thread requires <channel-id-or-name>');
+    }
+    const title = getStringFlag(flags, ['title']);
+    const openingMessage = getStringFlag(flags, ['message']);
+    if (!title || !openingMessage) {
+        throw new Error('create-thread requires --title <title> and --message <text>');
+    }
+    const { client } = await connectClient(flags, state);
+    try {
+        const channelId = resolveChannelId(client, channelRef);
+        const beforeIds = new Set(client.listThreads(channelId).map(row => row.id.toString()));
+        await client.createThread(channelId, title, openingMessage);
+        const created = findCreatedThread(client, channelId, title, beforeIds);
+        console.log(JSON.stringify({
+            ok: true,
+            channelId: channelId.toString(),
+            thread: created ? toThreadDto(created) : null,
+        }, null, 2));
+    }
+    finally {
+        client.disconnect();
+    }
+}
+async function commandSend(flags, positionals, state) {
+    const threadIdRaw = positionals[0];
+    if (!threadIdRaw) {
+        throw new Error('send requires <thread-id>');
+    }
+    const message = getStringFlag(flags, ['message']);
+    if (!message) {
+        throw new Error('send requires --message <text>');
+    }
+    const threadId = parseRequiredBigInt(threadIdRaw, 'thread-id');
+    const { client } = await connectClient(flags, state);
+    try {
+        await client.sendThreadMessage(threadId, message);
+        console.log(JSON.stringify({
+            ok: true,
+            threadId: threadId.toString(),
+            text: message,
+        }, null, 2));
+    }
+    finally {
+        client.disconnect();
+    }
+}
+async function commandWatch(flags, positionals, state) {
+    const threadIdRaw = positionals[0];
+    if (!threadIdRaw) {
+        throw new Error('watch requires <thread-id>');
+    }
+    const threadId = parseRequiredBigInt(threadIdRaw, 'thread-id');
+    const jsonl = getBooleanFlag(flags, ['jsonl']);
+    const { client, state: resolvedState } = await connectClient(flags, state);
+    const header = {
+        event: 'ready',
+        identity: client.identityHex,
+        threadId: threadId.toString(),
+        host: resolvedState.host,
+        databaseName: resolvedState.databaseName,
+    };
+    if (jsonl) {
+        emitJsonLine(header);
+    }
+    else {
+        console.log(`watching thread ${threadId.toString()} as ${client.identityHex.slice(0, 12)}...`);
+    }
+    const snapshot = client.listMessages(threadId).map(toMessageDto);
+    for (const row of snapshot) {
+        if (jsonl) {
+            emitJsonLine({ event: 'snapshot', message: row });
+        }
+        else {
+            console.log(formatHumanMessage(row));
+        }
+    }
+    const detach = client.onMessageInsert(row => {
+        if (row.threadId !== threadId) {
+            return;
+        }
+        const message = toMessageDto(row);
+        if (jsonl) {
+            emitJsonLine({ event: 'message', message });
+        }
+        else {
+            console.log(formatHumanMessage(message));
+        }
+    });
+    const cleanup = () => {
+        detach();
+        client.disconnect();
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    await new Promise(() => undefined);
+}
+function resolveCommandChannelId(client, payload) {
+    const byId = payload.channel_id;
+    if (byId !== undefined) {
+        return parseRequiredBigInt(String(byId), 'channel_id');
+    }
+    const byName = payload.channel;
+    if (typeof byName === 'string') {
+        return resolveChannelId(client, byName);
+    }
+    throw new Error('command requires channel_id or channel');
+}
+async function commandRunJsonl(flags, state) {
+    const { client, state: resolvedState } = await connectClient(flags, state);
+    const subscribedThreads = new Set();
+    const send = (event, data, id) => {
+        emitJsonLine({
+            ...(id !== undefined ? { id } : {}),
+            event,
+            ...data,
+        });
+    };
+    send('ready', {
+        identity: client.identityHex,
+        host: resolvedState.host,
+        databaseName: resolvedState.databaseName,
+        statePath: STATE_PATH,
+        commands: [
+            'ping',
+            'list_channels',
+            'create_channel',
+            'join_channel',
+            'leave_channel',
+            'list_threads',
+            'create_thread',
+            'list_messages',
+            'send',
+            'subscribe_thread',
+            'unsubscribe_thread',
+        ],
+    });
+    const detach = client.onMessageInsert(row => {
+        const threadId = row.threadId.toString();
+        if (!subscribedThreads.has(threadId)) {
+            return;
+        }
+        send('message', {
+            message: toMessageDto(row),
+        });
+    });
+    const rl = node_readline_1.default.createInterface({
+        input: process.stdin,
+        crlfDelay: Infinity,
+    });
+    const cleanup = () => {
+        detach();
+        rl.close();
+        client.disconnect();
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    rl.on('line', (line) => {
+        void (async () => {
+            if (!line.trim()) {
+                return;
+            }
+            let payload;
+            try {
+                payload = JSON.parse(line);
+            }
+            catch {
+                send('error', { error: 'invalid_json' });
+                return;
+            }
+            const id = typeof payload.id === 'string' || typeof payload.id === 'number'
+                ? payload.id
+                : undefined;
+            const command = payload.cmd;
+            if (typeof command !== 'string') {
+                send('error', { error: 'missing_cmd' }, id);
+                return;
+            }
+            try {
+                if (command === 'ping') {
+                    send('ok', { pong: true }, id);
+                    return;
+                }
+                if (command === 'list_channels') {
+                    send('ok', {
+                        channels: client.listChannels().map(toChannelDto),
+                    }, id);
+                    return;
+                }
+                if (command === 'create_channel') {
+                    const name = String(payload.name ?? '').trim();
+                    const topic = String(payload.topic ?? '').trim();
+                    if (!name) {
+                        throw new Error('create_channel requires name');
+                    }
+                    await client.createChannel(name, topic);
+                    const created = client.listChannels().find(row => row.name === name);
+                    send('ok', {
+                        channel: created ? toChannelDto(created) : { id: null, name, topic },
+                    }, id);
+                    return;
+                }
+                if (command === 'join_channel') {
+                    const channelId = resolveCommandChannelId(client, payload);
+                    await client.joinChannel(channelId);
+                    send('ok', { channelId: channelId.toString() }, id);
+                    return;
+                }
+                if (command === 'leave_channel') {
+                    const channelId = resolveCommandChannelId(client, payload);
+                    await client.leaveChannel(channelId);
+                    send('ok', { channelId: channelId.toString() }, id);
+                    return;
+                }
+                if (command === 'list_threads') {
+                    const channelId = payload.channel_id !== undefined || payload.channel !== undefined
+                        ? resolveCommandChannelId(client, payload)
+                        : undefined;
+                    send('ok', {
+                        threads: client.listThreads(channelId).map(toThreadDto),
+                    }, id);
+                    return;
+                }
+                if (command === 'create_thread') {
+                    const channelId = resolveCommandChannelId(client, payload);
+                    const title = String(payload.title ?? '');
+                    const openingMessage = String(payload.opening_message ?? '');
+                    if (!title.trim() || !openingMessage.trim()) {
+                        throw new Error('create_thread requires title and opening_message');
+                    }
+                    const beforeIds = new Set(client.listThreads(channelId).map(row => row.id.toString()));
+                    await client.createThread(channelId, title, openingMessage);
+                    const created = findCreatedThread(client, channelId, title, beforeIds);
+                    send('ok', {
+                        thread: created ? toThreadDto(created) : null,
+                    }, id);
+                    return;
+                }
+                if (command === 'list_messages') {
+                    const threadIdRaw = payload.thread_id;
+                    if (threadIdRaw === undefined) {
+                        throw new Error('list_messages requires thread_id');
+                    }
+                    const threadId = parseRequiredBigInt(String(threadIdRaw), 'thread_id');
+                    send('ok', {
+                        messages: client.listMessages(threadId).map(toMessageDto),
+                    }, id);
+                    return;
+                }
+                if (command === 'send') {
+                    const threadIdRaw = payload.thread_id;
+                    const text = String(payload.text ?? '');
+                    if (threadIdRaw === undefined || !text.trim()) {
+                        throw new Error('send requires thread_id and text');
+                    }
+                    const threadId = parseRequiredBigInt(String(threadIdRaw), 'thread_id');
+                    await client.sendThreadMessage(threadId, text);
+                    send('ok', {
+                        threadId: threadId.toString(),
+                        text,
+                    }, id);
+                    return;
+                }
+                if (command === 'subscribe_thread') {
+                    const threadIdRaw = payload.thread_id;
+                    if (threadIdRaw === undefined) {
+                        throw new Error('subscribe_thread requires thread_id');
+                    }
+                    const threadId = parseRequiredBigInt(String(threadIdRaw), 'thread_id');
+                    const threadIdText = threadId.toString();
+                    subscribedThreads.add(threadIdText);
+                    const snapshot = client.listMessages(threadId).map(toMessageDto);
+                    for (const message of snapshot) {
+                        send('snapshot', { message });
+                    }
+                    send('ok', { threadId: threadIdText, subscribed: true }, id);
+                    return;
+                }
+                if (command === 'unsubscribe_thread') {
+                    const threadIdRaw = payload.thread_id;
+                    if (threadIdRaw === undefined) {
+                        throw new Error('unsubscribe_thread requires thread_id');
+                    }
+                    const threadId = parseRequiredBigInt(String(threadIdRaw), 'thread_id');
+                    const threadIdText = threadId.toString();
+                    subscribedThreads.delete(threadIdText);
+                    send('ok', { threadId: threadIdText, subscribed: false }, id);
+                    return;
+                }
+                send('error', { error: `unknown_cmd:${command}` }, id);
+            }
+            catch (error) {
+                send('error', {
+                    error: error instanceof Error ? error.message : String(error),
+                }, id);
+            }
+        })();
+    });
+    await new Promise(() => undefined);
+}
+async function main() {
+    const [command = 'help', ...rest] = process.argv.slice(2);
+    const { flags, positionals } = parseArgs(rest);
+    const state = await loadState();
+    if (command === 'help' || command === '--help') {
+        printHelp();
+        return;
+    }
+    if (command === 'signup') {
+        await commandSignup(flags, positionals, state);
+        return;
+    }
+    if (command === 'whoami') {
+        await commandWhoami(flags, state);
+        return;
+    }
+    if (command === 'channels') {
+        await commandChannels(flags, state);
+        return;
+    }
+    if (command === 'create-channel') {
+        await commandCreateChannel(flags, state);
+        return;
+    }
+    if (command === 'join') {
+        await commandJoinOrLeave('join', flags, positionals, state);
+        return;
+    }
+    if (command === 'leave') {
+        await commandJoinOrLeave('leave', flags, positionals, state);
+        return;
+    }
+    if (command === 'threads') {
+        await commandThreads(flags, positionals, state);
+        return;
+    }
+    if (command === 'create-thread') {
+        await commandCreateThread(flags, positionals, state);
+        return;
+    }
+    if (command === 'send') {
+        await commandSend(flags, positionals, state);
+        return;
+    }
+    if (command === 'watch') {
+        await commandWatch(flags, positionals, state);
+        return;
+    }
+    if (command === 'run') {
+        if (!getBooleanFlag(flags, ['jsonl'])) {
+            throw new Error('run requires --jsonl');
+        }
+        await commandRunJsonl(flags, state);
+        return;
+    }
+    throw new Error(`Unknown command: ${command}`);
+}
+main().catch(error => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { AgentRealtimeClient, type AgentClientOptions, type AgentRole, type SignUpInput, } from './agent-client';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRealtimeClient = void 0;
+var agent_client_1 = require("./agent-client");
+Object.defineProperty(exports, "AgentRealtimeClient", { enumerable: true, get: function () { return agent_client_1.AgentRealtimeClient; } });

package/dist/module_bindings/channel_member_table.d.ts

@@ -0,0 +1,15 @@
+declare const _default: import("spacetimedb").RowBuilder<{
+    id: import("spacetimedb").U64ColumnBuilder<{
+        isPrimaryKey: true;
+    }>;
+    channelId: import("spacetimedb").U64ColumnBuilder<{
+        name: "channel_id";
+    }>;
+    memberIdentity: import("spacetimedb").IdentityColumnBuilder<{
+        name: "member_identity";
+    }>;
+    joinedAt: import("spacetimedb").TimestampColumnBuilder<{
+        name: "joined_at";
+    }>;
+}>;
+export default _default;