@assistkick/create 1.9.0 → 1.11.0

package/templates/assistkick-product-system/packages/backend/src/services/chat_cli_bridge.ts

@@ -0,0 +1,345 @@
+/**
+ * ChatCliBridge — spawns Claude Code CLI in non-interactive mode for Chat v2.
+ *
+ * Each user message spawns a new CLI invocation:
+ *   claude -p - --output-format stream-json --verbose --include-partial-messages
+ *          --append-system-prompt "We are working on project-id ${projectId}"
+ *
+ * New sessions use --session-id <uuid>, subsequent messages use --resume <uuid>.
+ * Permission mode controls: --dangerously-skip-permissions, --allowedTools, or --permission-prompt-tool.
+ * When permission mode is 'prompt', a temporary MCP config file is generated
+ * pointing to the permission MCP server, and --mcp-config is passed to the CLI.
+ * Emits parsed stream-json events via onEvent callback for downstream WebSocket forwarding.
+ */
+
+import { spawn, type ChildProcess } from 'node:child_process';
+import { join } from 'node:path';
+import { existsSync, mkdirSync } from 'node:fs';
+
+export type PermissionMode = 'skip' | 'allowed_tools';
+
+export interface ChatCliBridgeDeps {
+  workspacesDir: string;
+  log: (tag: string, ...args: unknown[]) => void;
+}
+
+export interface SpawnOptions {
+  projectId: string;
+  message: string;
+  claudeSessionId: string;
+  isNewSession: boolean;
+  permissionMode: PermissionMode;
+  allowedTools?: string[];
+  /** Compacted conversation context to prepend to the system prompt */
+  continuationContext?: string;
+  onEvent: (event: Record<string, unknown>) => void;
+}
+
+export interface SpawnCompletion {
+  exitCode: number | null;
+  claudeSessionId: string;
+  sessionId: string | null;
+  /** Captured stderr lines (if any) — useful for diagnosing non-zero exit codes */
+  stderr: string | null;
+  /** Non-JSON lines from stdout (if any) — CLI errors often appear here */
+  stdoutNonJsonLines: string | null;
+}
+
+export interface SpawnResult {
+  childProcess: ChildProcess;
+  completion: Promise<SpawnCompletion>;
+  /** The composed system prompt text (only set when isNewSession is true). */
+  systemPrompt: string | null;
+}
+
+export class ChatCliBridge {
+  private readonly workspacesDir: string;
+  private readonly log: ChatCliBridgeDeps['log'];
+  private readonly activeProcesses = new Map<string, ChildProcess>();
+
+  constructor({ workspacesDir, log }: ChatCliBridgeDeps) {
+    this.workspacesDir = workspacesDir;
+    this.log = log;
+  }
+
+  /**
+   * Resolve the workspace directory for a project.
+   * The CLI runs with cwd set to this path.
+   */
+  getWorkspaceCwd = (projectId: string): string => {
+    return join(this.workspacesDir, projectId);
+  };
+
+  /**
+   * Build the CLI arguments array from spawn options.
+   * Returns both the args array and the composed system prompt text (if any).
+   */
+  buildArgs = (options: SpawnOptions): { args: string[]; systemPrompt: string | null } => {
+    const { projectId, claudeSessionId, isNewSession, permissionMode, allowedTools, continuationContext } = options;
+    const args: string[] = [];
+    let systemPrompt: string | null = null;
+
+    // Permission mode
+    if (permissionMode === 'skip') {
+      args.push('--dangerously-skip-permissions');
+    } else if (permissionMode === 'allowed_tools' && allowedTools && allowedTools.length > 0) {
+      for (const tool of allowedTools) {
+        args.push('--allowedTools', tool);
+      }
+    }
+
+    // Prompt via stdin
+    args.push('-p', '-');
+
+    // Session management
+    if (isNewSession) {
+      args.push('--session-id', claudeSessionId);
+    } else {
+      args.push('--resume', claudeSessionId);
+    }
+
+    // Output format
+    args.push('--output-format', 'stream-json');
+    args.push('--verbose');
+    args.push('--include-partial-messages');
+
+    // Project context system prompt (only on first message; resumed sessions already have it)
+    if (isNewSession) {
+      const systemParts: string[] = [];
+
+      // Prepend compacted conversation context when continuing from a previous session
+      if (continuationContext) {
+        systemParts.push(continuationContext);
+      }
+
+      systemParts.push(`We are working on project-id ${projectId}
+      You are only allowed to read/write/edit/delete (any work with) files in the /workspaces/${projectId} directory.
+
+      ## Git Repository Structure
+      Each project workspace (workspaces/${projectId}/) has its OWN independent git repo
+      When committing and pushing changes, always use the workspace git repo (your cwd), not the top-level repo.
+      The skill files (.claude/skills/) and project code are tracked in the workspace repo.
+
+      ## Skills
+      Project skills (e.g. assistkick-interview, assistkick-developer, etc.) are defined in .claude/skills/ within this workspace.
+      To invoke a skill, always use the Skill tool (e.g. Skill with skill: "assistkick-interview"). Do NOT manually read or execute skill files — the Skill tool handles loading and execution.
+      Only edit code and project files — never modify the skill definition files in .claude/skills/.`);
+
+      systemPrompt = systemParts.join('\n\n');
+      args.push('--append-system-prompt', systemPrompt);
+    }
+
+    return { args, systemPrompt };
+  };
+
+  /**
+   * Build environment variables for the CLI subprocess.
+   * Ensures common bin paths are available.
+   */
+  buildEnv = (): Record<string, string> => {
+    const env = { ...process.env } as Record<string, string>;
+    const home = env.HOME || '/root';
+    const extraPaths = [
+      `${home}/.local/bin`,
+      `${home}/.npm-global/bin`,
+      `${home}/.nvm/current/bin`,
+      '/usr/local/bin',
+      '/opt/homebrew/bin',
+    ];
+    const existing = env.PATH || '/usr/bin:/bin';
+    const missing = extraPaths.filter(p => !existing.split(':').includes(p));
+    if (missing.length) {
+      env.PATH = [...missing, existing].join(':');
+    }
+    return env;
+  };
+
+  /**
+   * Spawn a Claude CLI process for a chat message.
+   * Returns a handle to the child process and a promise that resolves on completion.
+   */
+  spawn = (options: SpawnOptions): SpawnResult => {
+    const { projectId, message, claudeSessionId, isNewSession, onEvent } = options;
+    const cwd = this.getWorkspaceCwd(projectId);
+    const { args, systemPrompt } = this.buildArgs(options);
+
+    // Ensure workspace directory exists (Docker volumes may not have project subdirs)
+    if (!existsSync(cwd)) {
+      mkdirSync(cwd, { recursive: true });
+    }
+
+    const mode = isNewSession ? 'new' : 'resume';
+    this.log('CHAT_CLI', `Spawning claude (${mode}) for project ${projectId}, session ${claudeSessionId}`);
+    this.log('CHAT_CLI', `cwd: ${cwd} (exists: ${existsSync(cwd)}), args: claude ${args.join(' ')}`);
+
+    const child = spawn('claude', args, {
+      cwd,
+      env: this.buildEnv(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    // Track active process by session
+    this.activeProcesses.set(claudeSessionId, child);
+
+    const completion = new Promise<SpawnCompletion>((resolve, reject) => {
+      let lineBuf = '';
+      let capturedSessionId: string | null = null;
+      let stdoutReceived = false;
+      let stderrLines: string[] = [];
+      let stdoutNonJsonLines: string[] = [];
+
+      child.stdout!.on('data', (chunk: Buffer) => {
+        stdoutReceived = true;
+        lineBuf += chunk.toString();
+        const lines = lineBuf.split('\n');
+        lineBuf = lines.pop()!;
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          this.processLine(trimmed, onEvent, (sid) => {
+            capturedSessionId = sid;
+          }, (nonJsonLine) => {
+            stdoutNonJsonLines.push(nonJsonLine);
+          });
+        }
+      });
+
+      child.stderr!.on('data', (chunk: Buffer) => {
+        const text = chunk.toString();
+        text.split('\n').forEach(line => {
+          if (line.trim()) {
+            stderrLines.push(line.trim());
+            this.log('CHAT_CLI', `[stderr] ${line.trim()}`);
+          }
+        });
+      });
+
+      // Write the message to stdin and close
+      child.stdin!.write(message);
+      child.stdin!.end();
+      this.log('CHAT_CLI', `Message written to stdin (${message.length} chars)`);
+
+      child.on('close', (code) => {
+        // Process any remaining data in the line buffer
+        if (lineBuf.trim()) {
+          this.processLine(lineBuf.trim(), onEvent, (sid) => {
+            capturedSessionId = sid;
+          }, (nonJsonLine) => {
+            stdoutNonJsonLines.push(nonJsonLine);
+          });
+        }
+
+        this.activeProcesses.delete(claudeSessionId);
+
+        if (code !== 0) {
+          this.log('CHAT_CLI', `Process FAILED with exit code ${code} for session ${claudeSessionId}`);
+          if (stderrLines.length > 0) {
+            this.log('CHAT_CLI', `[stderr summary] ${stderrLines.join(' | ')}`);
+          }
+          if (stdoutNonJsonLines.length > 0) {
+            this.log('CHAT_CLI', `[stdout non-json summary] ${stdoutNonJsonLines.join(' | ')}`);
+          }
+          if (!stdoutReceived) {
+            this.log('CHAT_CLI', `No stdout received — CLI may have crashed or failed to start`);
+          }
+        } else {
+          this.log('CHAT_CLI', `Process exited successfully for session ${claudeSessionId}`);
+        }
+
+        resolve({
+          exitCode: code,
+          claudeSessionId,
+          sessionId: capturedSessionId,
+          stderr: stderrLines.length > 0 ? stderrLines.join('\n') : null,
+          stdoutNonJsonLines: stdoutNonJsonLines.length > 0 ? stdoutNonJsonLines.join('\n') : null,
+        });
+      });
+
+      child.on('error', (err) => {
+        this.activeProcesses.delete(claudeSessionId);
+        this.log('CHAT_CLI', `Process spawn error for session ${claudeSessionId}: ${err.message} (${(err as NodeJS.ErrnoException).code || 'unknown'})`);
+        reject(err);
+      });
+    });
+
+    return { childProcess: child, completion, systemPrompt };
+  };
+
+  /**
+   * Kill an active CLI process by session ID.
+   * Returns true if a process was found and killed.
+   */
+  kill = (claudeSessionId: string): boolean => {
+    const child = this.activeProcesses.get(claudeSessionId);
+    if (!child) return false;
+
+    this.log('CHAT_CLI', `Killing process for session ${claudeSessionId}`);
+    child.kill('SIGTERM');
+
+    // Force kill after 5 seconds if still alive
+    const forceKillTimer = setTimeout(() => {
+      if (!child.killed) {
+        this.log('CHAT_CLI', `Force killing process for session ${claudeSessionId}`);
+        child.kill('SIGKILL');
+      }
+    }, 5000);
+
+    child.on('close', () => {
+      clearTimeout(forceKillTimer);
+    });
+
+    return true;
+  };
+
+  /**
+   * Kill all active CLI processes (for server shutdown).
+   */
+  killAll = (): void => {
+    for (const [sessionId, child] of this.activeProcesses) {
+      this.log('CHAT_CLI', `Killing process for session ${sessionId} (shutdown)`);
+      child.kill('SIGTERM');
+    }
+    this.activeProcesses.clear();
+  };
+
+  /**
+   * Check if a process is currently active for a session.
+   */
+  isActive = (claudeSessionId: string): boolean => {
+    return this.activeProcesses.has(claudeSessionId);
+  };
+
+  /**
+   * Get the number of currently active processes.
+   */
+  getActiveCount = (): number => {
+    return this.activeProcesses.size;
+  };
+
+  /**
+   * Parse a single line of stream-json output and emit events.
+   * Also captures session_id from result events.
+   */
+  private processLine = (
+    line: string,
+    onEvent: (event: Record<string, unknown>) => void,
+    onSessionId: (sessionId: string) => void,
+    onNonJsonLine?: (line: string) => void,
+  ): void => {
+    try {
+      const event = JSON.parse(line) as Record<string, unknown>;
+      onEvent(event);
+
+      // Capture session_id from result event
+      if (event.type === 'result' && typeof event.session_id === 'string') {
+        onSessionId(event.session_id);
+      }
+    } catch {
+      // Not valid JSON — log and capture it as it may contain useful error info
+      const truncated = line.slice(0, 500);
+      this.log('CHAT_CLI', `[stdout non-json] ${truncated}`);
+      onNonJsonLine?.(truncated);
+    }
+  };
+}

package/templates/assistkick-product-system/packages/backend/src/services/chat_message_repository.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, mock, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { ChatMessageRepository } from './chat_message_repository.ts';
+
+const createMockDb = () => {
+  let selectResults: any[][] = [];
+  let selectCallIndex = 0;
+
+  const db = {
+    select: mock.fn(() => ({
+      from: mock.fn(() => ({
+        where: mock.fn(() => {
+          const result = selectResults[selectCallIndex] || [];
+          selectCallIndex++;
+          return Object.assign(result, {
+            orderBy: mock.fn(() => result),
+          });
+        }),
+      })),
+    })),
+    insert: mock.fn(() => ({
+      values: mock.fn(() => Promise.resolve()),
+    })),
+    delete: mock.fn(() => ({
+      where: mock.fn(() => Promise.resolve({ changes: 3 })),
+    })),
+    _setSelectResults: (results: any[][]) => {
+      selectResults = results;
+      selectCallIndex = 0;
+    },
+  };
+
+  return db;
+};
+
+const createRepository = (db: any) => {
+  return new ChatMessageRepository({
+    getDb: () => db,
+    log: mock.fn(),
+  });
+};
+
+describe('ChatMessageRepository', () => {
+  let db: ReturnType<typeof createMockDb>;
+  let repo: ChatMessageRepository;
+
+  beforeEach(() => {
+    db = createMockDb();
+    repo = createRepository(db);
+  });
+
+  describe('generateId', () => {
+    it('returns an id with cmsg_ prefix', () => {
+      const id = repo.generateId();
+      assert.ok(id.startsWith('cmsg_'));
+      assert.ok(id.length > 5);
+    });
+
+    it('generates unique ids', () => {
+      const id1 = repo.generateId();
+      const id2 = repo.generateId();
+      assert.notEqual(id1, id2);
+    });
+  });
+
+  describe('getNextOrderIndex', () => {
+    it('returns 0 when no messages exist', async () => {
+      db._setSelectResults([[{ maxIndex: null }]]);
+      const index = await repo.getNextOrderIndex('csess_abc');
+      assert.equal(index, 0);
+    });
+
+    it('returns max + 1 when messages exist', async () => {
+      db._setSelectResults([[{ maxIndex: 5 }]]);
+      const index = await repo.getNextOrderIndex('csess_abc');
+      assert.equal(index, 6);
+    });
+
+    it('returns 1 when max is 0', async () => {
+      db._setSelectResults([[{ maxIndex: 0 }]]);
+      const index = await repo.getNextOrderIndex('csess_abc');
+      assert.equal(index, 1);
+    });
+  });
+
+  describe('saveMessage', () => {
+    it('inserts a message and returns the saved row', async () => {
+      const row = await repo.saveMessage(
+        'csess_abc',
+        'user',
+        JSON.stringify([{ type: 'text', text: 'Hello' }]),
+        0,
+      );
+
+      assert.ok(row.id.startsWith('cmsg_'));
+      assert.equal(row.sessionId, 'csess_abc');
+      assert.equal(row.role, 'user');
+      assert.equal(row.orderIndex, 0);
+      assert.ok(row.createdAt);
+
+      const content = JSON.parse(row.content);
+      assert.equal(content[0].type, 'text');
+      assert.equal(content[0].text, 'Hello');
+
+      assert.equal(db.insert.mock.calls.length, 1);
+    });
+
+    it('saves assistant messages with complex content', async () => {
+      const content = JSON.stringify([
+        { type: 'text', text: 'Here is the code:' },
+        { type: 'tool_use', id: 'tu_1', name: 'Write', input: { path: '/test.ts' } },
+      ]);
+
+      const row = await repo.saveMessage('csess_abc', 'assistant', content, 1);
+
+      assert.equal(row.role, 'assistant');
+      assert.equal(row.orderIndex, 1);
+
+      const parsed = JSON.parse(row.content);
+      assert.equal(parsed.length, 2);
+      assert.equal(parsed[0].type, 'text');
+      assert.equal(parsed[1].type, 'tool_use');
+    });
+  });
+
+  describe('getMessages', () => {
+    it('returns messages for a session ordered by index', async () => {
+      const mockMessages = [
+        {
+          id: 'cmsg_001',
+          sessionId: 'csess_abc',
+          role: 'user',
+          content: JSON.stringify([{ type: 'text', text: 'Hello' }]),
+          orderIndex: 0,
+          createdAt: '2026-03-11T14:00:00.000Z',
+        },
+        {
+          id: 'cmsg_002',
+          sessionId: 'csess_abc',
+          role: 'assistant',
+          content: JSON.stringify([{ type: 'text', text: 'Hi there!' }]),
+          orderIndex: 1,
+          createdAt: '2026-03-11T14:00:01.000Z',
+        },
+      ];
+      db._setSelectResults([mockMessages]);
+
+      const messages = await repo.getMessages('csess_abc');
+      assert.equal(messages.length, 2);
+      assert.equal(messages[0].role, 'user');
+      assert.equal(messages[1].role, 'assistant');
+      assert.equal(messages[0].orderIndex, 0);
+      assert.equal(messages[1].orderIndex, 1);
+    });
+
+    it('returns empty array when no messages exist', async () => {
+      db._setSelectResults([[]]);
+      const messages = await repo.getMessages('csess_nonexistent');
+      assert.equal(messages.length, 0);
+    });
+  });
+
+  describe('deleteBySessionId', () => {
+    it('deletes all messages for a session and returns count', async () => {
+      const count = await repo.deleteBySessionId('csess_abc');
+      assert.equal(count, 3);
+      assert.equal(db.delete.mock.calls.length, 1);
+    });
+  });
+});

package/templates/assistkick-product-system/packages/backend/src/services/chat_message_repository.ts

@@ -0,0 +1,106 @@
+/**
+ * ChatMessageRepository — persists chat messages in the database.
+ * Each message belongs to a chat session and stores role, content blocks
+ * (as JSON), an ordering index, and a timestamp.
+ */
+
+import { randomBytes } from 'node:crypto';
+import { eq, asc, max } from 'drizzle-orm';
+import { chatMessages } from '@assistkick/shared/db/schema.js';
+
+interface ChatMessageRepositoryDeps {
+  getDb: () => any;
+  log: (tag: string, ...args: unknown[]) => void;
+}
+
+export interface ChatMessageRow {
+  id: string;
+  sessionId: string;
+  role: string;
+  content: string;
+  orderIndex: number;
+  createdAt: string;
+}
+
+export class ChatMessageRepository {
+  private readonly getDb: ChatMessageRepositoryDeps['getDb'];
+  private readonly log: ChatMessageRepositoryDeps['log'];
+
+  constructor({ getDb, log }: ChatMessageRepositoryDeps) {
+    this.getDb = getDb;
+    this.log = log;
+  }
+
+  generateId = (): string => {
+    const hex = randomBytes(4).toString('hex');
+    return `cmsg_${hex}`;
+  };
+
+  /** Get the next available order index for a session. */
+  getNextOrderIndex = async (sessionId: string): Promise<number> => {
+    const db = this.getDb();
+    const result = await db
+      .select({ maxIndex: max(chatMessages.orderIndex) })
+      .from(chatMessages)
+      .where(eq(chatMessages.sessionId, sessionId));
+    const current = result[0]?.maxIndex;
+    return current != null ? current + 1 : 0;
+  };
+
+  /** Save a single message. Returns the saved row. */
+  saveMessage = async (
+    sessionId: string,
+    role: string,
+    content: string,
+    orderIndex: number,
+  ): Promise<ChatMessageRow> => {
+    const id = this.generateId();
+    const createdAt = new Date().toISOString();
+
+    const db = this.getDb();
+    await db.insert(chatMessages).values({
+      id,
+      sessionId,
+      role,
+      content,
+      orderIndex,
+      createdAt,
+    });
+
+    this.log('CHAT_MSG', `Saved ${role} message ${id} at index ${orderIndex} for session ${sessionId}`);
+
+    return { id, sessionId, role, content, orderIndex, createdAt };
+  };
+
+  /** Load all messages for a session, ordered by orderIndex ascending. */
+  getMessages = async (sessionId: string): Promise<ChatMessageRow[]> => {
+    const db = this.getDb();
+    const rows = await db
+      .select()
+      .from(chatMessages)
+      .where(eq(chatMessages.sessionId, sessionId))
+      .orderBy(asc(chatMessages.orderIndex));
+    return rows as ChatMessageRow[];
+  };
+
+  /** Update the content of an existing message (used to finalize partial assistant responses). */
+  updateMessageContent = async (id: string, content: string): Promise<void> => {
+    const db = this.getDb();
+    await db
+      .update(chatMessages)
+      .set({ content })
+      .where(eq(chatMessages.id, id));
+    this.log('CHAT_MSG', `Updated content for message ${id}`);
+  };
+
+  /** Delete all messages for a session (used when session is deleted). */
+  deleteBySessionId = async (sessionId: string): Promise<number> => {
+    const db = this.getDb();
+    const result = await db
+      .delete(chatMessages)
+      .where(eq(chatMessages.sessionId, sessionId));
+    const count = result.changes ?? 0;
+    this.log('CHAT_MSG', `Deleted ${count} messages for session ${sessionId}`);
+    return count;
+  };
+}