@assistkick/create 1.10.0 → 1.12.0

package/templates/assistkick-product-system/packages/shared/db/migrations/meta/_journal.json

@@ -5,106 +5,8 @@
     {
       "idx": 0,
       "version": "6",
-      "when": 1772730355833,
-      "tag": "0000_dashing_gorgon",
-      "breakpoints": true
-    },
-    {
-      "idx": 1,
-      "version": "6",
-      "when": 1772802625250,
-      "tag": "0001_vengeful_wallop",
-      "breakpoints": true
-    },
-    {
-      "idx": 2,
-      "version": "6",
-      "when": 1772807644324,
-      "tag": "0002_greedy_excalibur",
-      "breakpoints": true
-    },
-    {
-      "idx": 3,
-      "version": "6",
-      "when": 1772812820535,
-      "tag": "0003_lonely_cyclops",
-      "breakpoints": true
-    },
-    {
-      "idx": 4,
-      "version": "6",
-      "when": 1772975082564,
-      "tag": "0004_tidy_matthew_murdock",
-      "breakpoints": true
-    },
-    {
-      "idx": 5,
-      "version": "6",
-      "when": 1772982318304,
-      "tag": "0005_mysterious_falcon",
-      "breakpoints": true
-    },
-    {
-      "idx": 6,
-      "version": "6",
-      "when": 1772984904854,
-      "tag": "0006_next_venom",
-      "breakpoints": true
-    },
-    {
-      "idx": 7,
-      "version": "6",
-      "when": 1773003174080,
-      "tag": "0007_deep_barracuda",
-      "breakpoints": true
-    },
-    {
-      "idx": 8,
-      "version": "6",
-      "when": 1773122459461,
-      "tag": "0008_puzzling_hannibal_king",
-      "breakpoints": true
-    },
-    {
-      "idx": 9,
-      "version": "6",
-      "when": 1773127312138,
-      "tag": "0009_amused_beast",
-      "breakpoints": true
-    },
-    {
-      "idx": 10,
-      "version": "6",
-      "when": 1773143546640,
-      "tag": "0010_spotty_moira_mactaggert",
-      "breakpoints": true
-    },
-    {
-      "idx": 11,
-      "version": "6",
-      "when": 1773169770877,
-      "tag": "0011_supreme_doctor_octopus",
-      "breakpoints": true
-    },
-    {
-      "idx": 12,
-      "version": "6",
-      "when": 1773170271654,
-      "tag": "0011_goofy_snowbird",
-      "breakpoints": true
-    },
-    {
-      "idx": 13,
-      "version": "6",
-      "when": 1773179139368,
-      "tag": "0013_reflective_prowler",
-      "breakpoints": true
-    },
-    {
-      "idx": 14,
-      "version": "6",
-      "when": 1773187819583,
-      "tag": "0014_nifty_punisher",
+      "when": 1773826299804,
+      "tag": "0000_outgoing_ultron",
       "breakpoints": true
     }
   ]

package/templates/assistkick-product-system/packages/shared/db/schema.ts

@@ -130,6 +130,7 @@ export const projects = sqliteTable('projects', {
   gitAuthMethod: text('git_auth_method'),
   sshPrivateKeyEncrypted: text('ssh_private_key_encrypted'),
   sshPublicKey: text('ssh_public_key'),
+  previewCommand: text('preview_command'),
   createdAt: text('created_at').notNull(),
   updatedAt: text('updated_at').notNull(),
 });
@@ -141,6 +142,7 @@ export const terminalSessions = sqliteTable('terminal_sessions', {
   projectId: text('project_id').notNull(),
   projectName: text('project_name').notNull(),
   name: text('name').notNull(),
+  sessionType: text('session_type').notNull().default('claude'),
   createdAt: text('created_at').notNull(),
   lastUsedAt: text('last_used_at').notNull(),
 });
@@ -174,7 +176,10 @@ export const pipelineOutputs = sqliteTable('pipeline_outputs', {
 export const agents = sqliteTable('agents', {
   id: text('id').primaryKey(),
   name: text('name').notNull(),
-  promptTemplate: text('prompt_template').notNull(),
+  model: text('model').notNull().default('claude-opus-4-6'),
+  skills: text('skills').notNull().default('[]'),
+  grounding: text('grounding').notNull().default(''),
+  defaultGrounding: text('default_grounding'),
   projectId: text('project_id'),
   isDefault: integer('is_default').notNull().default(0),
   createdAt: text('created_at').notNull(),
@@ -228,6 +233,8 @@ export const workflowNodeExecutions = sqliteTable('workflow_node_executions', {
   outputData: text('output_data'),
   error: text('error'),
   attempt: integer('attempt').notNull().default(1),
+  cycle: integer('cycle').notNull().default(1),
+  claudeSessionId: text('claude_session_id'),
 });
 
 // --- workflow_tool_calls table ---
@@ -240,6 +247,38 @@ export const workflowToolCalls = sqliteTable('workflow_tool_calls', {
   createdAt: text('created_at').notNull(),
 });
 
+// --- chat_permission_rules table ---
+export const chatPermissionRules = sqliteTable('chat_permission_rules', {
+  id: text('id').primaryKey(),
+  projectId: text('project_id').notNull(),
+  toolName: text('tool_name').notNull(),
+  createdAt: text('created_at').notNull(),
+});
+
+// --- chat_messages table ---
+export const chatMessages = sqliteTable('chat_messages', {
+  id: text('id').primaryKey(),
+  sessionId: text('session_id').notNull(),
+  role: text('role').notNull(),
+  content: text('content').notNull(),
+  orderIndex: integer('order_index').notNull(),
+  createdAt: text('created_at').notNull(),
+});
+
+// --- chat_sessions table ---
+export const chatSessions = sqliteTable('chat_sessions', {
+  id: text('id').primaryKey(),
+  claudeSessionId: text('claude_session_id').notNull(),
+  projectId: text('project_id').notNull(),
+  name: text('name').notNull(),
+  permissionMode: text('permission_mode'),
+  continuationContext: text('continuation_context'),
+  systemPrompt: text('system_prompt'),
+  contextUsageJson: text('context_usage_json'),
+  createdAt: text('created_at').notNull(),
+  updatedAt: text('updated_at').notNull(),
+});
+
 // --- video_renders table ---
 export const videoRenders = sqliteTable('video_renders', {
   id: text('id').primaryKey(),

package/templates/assistkick-product-system/packages/shared/lib/claude-service.test.ts

@@ -0,0 +1,236 @@
+import { describe, it, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import {
+  emitResultEvent,
+  emitToolUseEvents,
+  emitAssistantTextEvents,
+  emitAssistantUsage,
+  createClaudeService,
+} from './claude-service.ts';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FIXTURES_DIR = join(__dirname, '..', 'test_fixtures');
+const HANGING_SCRIPT = join(FIXTURES_DIR, 'hanging_stream.mjs');
+
+// --- Unit tests for exported event parsers ---
+
+describe('emitResultEvent', () => {
+  it('fires callback with metadata for a result event', () => {
+    const resultJson = JSON.stringify({
+      type: 'result',
+      cost_usd: 0.05,
+      duration_ms: 2000,
+      num_turns: 3,
+      stop_reason: 'end_turn',
+      model: 'claude-opus-4-6',
+    });
+    const cb = mock.fn();
+    emitResultEvent(resultJson, cb);
+    assert.equal(cb.mock.calls.length, 1);
+    const metadata = cb.mock.calls[0].arguments[0];
+    assert.equal(metadata.costUsd, 0.05);
+    assert.equal(metadata.durationMs, 2000);
+    assert.equal(metadata.numTurns, 3);
+    assert.equal(metadata.stopReason, 'end_turn');
+    assert.equal(metadata.model, 'claude-opus-4-6');
+  });
+
+  it('does not fire for non-result events', () => {
+    const assistantJson = JSON.stringify({
+      type: 'assistant',
+      message: { content: [{ type: 'text', text: 'hello' }] },
+    });
+    const cb = mock.fn();
+    emitResultEvent(assistantJson, cb);
+    assert.equal(cb.mock.calls.length, 0);
+  });
+
+  it('does not fire for invalid JSON', () => {
+    const cb = mock.fn();
+    emitResultEvent('not json at all', cb);
+    assert.equal(cb.mock.calls.length, 0);
+  });
+
+  it('extracts contextWindow from modelUsage', () => {
+    const resultJson = JSON.stringify({
+      type: 'result',
+      model: 'claude-opus-4-6',
+      modelUsage: {
+        'claude-opus-4-6': { contextWindow: 85 },
+      },
+    });
+    const cb = mock.fn();
+    emitResultEvent(resultJson, cb);
+    assert.equal(cb.mock.calls[0].arguments[0].contextWindow, 85);
+  });
+});
+
+describe('emitToolUseEvents', () => {
+  it('fires callback for tool_use blocks', () => {
+    const json = JSON.stringify({
+      type: 'assistant',
+      message: {
+        content: [
+          { type: 'tool_use', name: 'Read', input: { file_path: '/tmp/test.ts' } },
+          { type: 'text', text: 'reading file' },
+          { type: 'tool_use', name: 'Edit', input: { file_path: '/tmp/test.ts' } },
+        ],
+      },
+    });
+    const cb = mock.fn();
+    emitToolUseEvents(json, cb);
+    assert.equal(cb.mock.calls.length, 2);
+    assert.equal(cb.mock.calls[0].arguments[0], 'Read');
+    assert.equal(cb.mock.calls[1].arguments[0], 'Edit');
+  });
+
+  it('does not fire for non-assistant events', () => {
+    const json = JSON.stringify({ type: 'result', result: 'done' });
+    const cb = mock.fn();
+    emitToolUseEvents(json, cb);
+    assert.equal(cb.mock.calls.length, 0);
+  });
+});
+
+describe('emitAssistantTextEvents', () => {
+  it('fires callback for text blocks', () => {
+    const json = JSON.stringify({
+      type: 'assistant',
+      message: {
+        content: [
+          { type: 'text', text: 'Hello world' },
+          { type: 'tool_use', name: 'Read', input: {} },
+          { type: 'text', text: 'Goodbye' },
+        ],
+      },
+    });
+    const cb = mock.fn();
+    emitAssistantTextEvents(json, cb);
+    assert.equal(cb.mock.calls.length, 2);
+    assert.equal(cb.mock.calls[0].arguments[0], 'Hello world');
+    assert.equal(cb.mock.calls[1].arguments[0], 'Goodbye');
+  });
+});
+
+describe('emitAssistantUsage', () => {
+  it('fires callback with usage data', () => {
+    const json = JSON.stringify({
+      type: 'assistant',
+      message: {
+        content: [],
+        usage: { input_tokens: 100, output_tokens: 50 },
+      },
+    });
+    const cb = mock.fn();
+    emitAssistantUsage(json, cb);
+    assert.equal(cb.mock.calls.length, 1);
+    assert.deepEqual(cb.mock.calls[0].arguments[0], { input_tokens: 100, output_tokens: 50 });
+  });
+});
+
+// --- Integration tests for post-result timeout ---
+
+describe('spawnClaude post-result timeout', () => {
+  it('kills a hanging process after result event and resolves successfully', async () => {
+    // This test spawns a process that emits a result event but never exits.
+    // We use a very short timeout (500ms) to keep the test fast.
+    // We can't use createClaudeService.spawnClaude directly because it hardcodes
+    // 'claude' as the command. Instead, we replicate the timeout logic pattern
+    // using spawn directly to verify the behavior.
+    const child = spawn('node', [HANGING_SCRIPT], {
+      cwd: process.cwd(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    const result = await new Promise<{ output: string; killedByTimeout: boolean }>((resolve) => {
+      let stdout = '';
+      let resultReceived = false;
+      let killedByTimeout = false;
+      let postResultTimer: ReturnType<typeof setTimeout> | null = null;
+      let sigkillTimer: ReturnType<typeof setTimeout> | null = null;
+      const POST_RESULT_TIMEOUT_MS = 500;
+
+      const startPostResultTimeout = () => {
+        if (postResultTimer) return;
+        resultReceived = true;
+        postResultTimer = setTimeout(() => {
+          killedByTimeout = true;
+          child.kill('SIGTERM');
+          sigkillTimer = setTimeout(() => {
+            try { child.kill('SIGKILL'); } catch { /* already dead */ }
+          }, 2_000);
+        }, POST_RESULT_TIMEOUT_MS);
+      };
+
+      child.stdout.on('data', (d) => {
+        const chunk = d.toString();
+        stdout += chunk;
+        for (const line of chunk.split('\n')) {
+          if (line.trim()) {
+            emitResultEvent(line.trim(), () => startPostResultTimeout());
+          }
+        }
+      });
+
+      child.stdin.write('test prompt');
+      child.stdin.end();
+
+      child.on('close', () => {
+        if (postResultTimer) clearTimeout(postResultTimer);
+        if (sigkillTimer) clearTimeout(sigkillTimer);
+        resolve({ output: stdout, killedByTimeout });
+      });
+    });
+
+    assert.equal(result.killedByTimeout, true, 'Process should have been killed by timeout');
+    assert.ok(result.output.includes('"type":"result"'), 'Output should contain result event');
+  });
+
+  it('does not kill the process when it exits normally before timeout', async () => {
+    // Process exits after 100ms, well before the 2000ms timeout
+    const child = spawn('node', [HANGING_SCRIPT, '--exit-after-ms', '100'], {
+      cwd: process.cwd(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    const result = await new Promise<{ killedByTimeout: boolean; exitCode: number | null }>((resolve) => {
+      let killedByTimeout = false;
+      let postResultTimer: ReturnType<typeof setTimeout> | null = null;
+      let sigkillTimer: ReturnType<typeof setTimeout> | null = null;
+
+      const startPostResultTimeout = () => {
+        if (postResultTimer) return;
+        postResultTimer = setTimeout(() => {
+          killedByTimeout = true;
+          child.kill('SIGTERM');
+          sigkillTimer = setTimeout(() => {
+            try { child.kill('SIGKILL'); } catch { /* already dead */ }
+          }, 2_000);
+        }, 2_000);
+      };
+
+      child.stdout.on('data', (d) => {
+        for (const line of d.toString().split('\n')) {
+          if (line.trim()) {
+            emitResultEvent(line.trim(), () => startPostResultTimeout());
+          }
+        }
+      });
+
+      child.stdin.write('test prompt');
+      child.stdin.end();
+
+      child.on('close', (code) => {
+        if (postResultTimer) clearTimeout(postResultTimer);
+        if (sigkillTimer) clearTimeout(sigkillTimer);
+        resolve({ killedByTimeout, exitCode: code });
+      });
+    });
+
+    assert.equal(result.killedByTimeout, false, 'Process should NOT have been killed by timeout');
+    assert.equal(result.exitCode, 0, 'Process should have exited normally');
+  });
+});

package/templates/assistkick-product-system/packages/shared/lib/claude-service.ts

@@ -205,7 +205,7 @@ export const emitAssistantUsage = (jsonStr, callback) => {
  * @returns {{ spawnClaude: function, spawnCommand: function }}
  */
 export const createClaudeService = ({ verbose = false, log: logFn }) => {
-  const spawnClaude = (prompt, cwd, label = 'claude', { onToolUse, onResult, onTurnUsage, onAssistantText } = {} as any) => new Promise((resolve, reject) => {
+  const spawnClaude = (prompt, cwd, label = 'claude', { onToolUse, onResult, onTurnUsage, onAssistantText, onSpawn, sessionId, resume: resumeSessionId, postResultTimeoutMs = 60_000, model: modelOverride } = {} as any) => new Promise((resolve, reject) => {
     const promptPreview = prompt.slice(0, 100).replace(/\n/g, '\\n');
     logFn('CLAUDE', `Spawning ${label} in ${cwd} — prompt length: ${prompt.length} chars`);
     logFn('CLAUDE', `Prompt preview: "${promptPreview}..."`);
@@ -214,7 +214,19 @@ export const createClaudeService = ({ verbose = false, log: logFn }) => {
     const hasCallbacks = !!(onToolUse || onResult || onTurnUsage || onAssistantText);
     const useStreamJson = verbose || hasCallbacks;
 
-    const claudeArgs = ['--dangerously-skip-permissions', '-p', '-'];
+    const claudeArgs: string[] = [];
+    if (resumeSessionId) {
+      // Resume an existing session — '--resume <id>' restores conversation context
+      claudeArgs.push('--resume', resumeSessionId, '--dangerously-skip-permissions', '-p', '-');
+    } else {
+      claudeArgs.push('--dangerously-skip-permissions', '-p', '-');
+      if (sessionId) {
+        claudeArgs.push('--session-id', sessionId);
+      }
+    }
+    if (modelOverride) {
+      claudeArgs.push('--model', modelOverride);
+    }
     if (useStreamJson) {
       claudeArgs.push('--verbose', '--output-format', 'stream-json');
     }
@@ -224,9 +236,29 @@ export const createClaudeService = ({ verbose = false, log: logFn }) => {
       env: process.env,
       stdio: ['pipe', 'pipe', 'pipe'],
     });
+
+    // Expose child process reference to caller for kill support
+    if (onSpawn) onSpawn(child);
     let stdout = '';
     let stderr = '';
     let lineBuf = '';
+    let resultReceived = false;
+    let killedByTimeout = false;
+    let postResultTimer: ReturnType<typeof setTimeout> | null = null;
+    let sigkillTimer: ReturnType<typeof setTimeout> | null = null;
+
+    const startPostResultTimeout = () => {
+      if (postResultTimer || !useStreamJson) return;
+      resultReceived = true;
+      postResultTimer = setTimeout(() => {
+        logFn('CLAUDE', `WARNING: ${label} process did not exit after result event — killing after ${postResultTimeoutMs / 1000}s timeout`);
+        killedByTimeout = true;
+        child.kill('SIGTERM');
+        sigkillTimer = setTimeout(() => {
+          try { child.kill('SIGKILL'); } catch { /* already dead */ }
+        }, 5_000);
+      }, postResultTimeoutMs);
+    };
 
     const tag = `${label.toUpperCase()}`;
 
@@ -241,7 +273,10 @@ export const createClaudeService = ({ verbose = false, log: logFn }) => {
           if (line.trim()) {
             if (verbose) formatStreamEvent(line.trim(), tag);
             if (onToolUse) emitToolUseEvents(line.trim(), onToolUse);
-            if (onResult) emitResultEvent(line.trim(), onResult);
+            emitResultEvent(line.trim(), (metadata) => {
+              if (onResult) onResult(metadata);
+              startPostResultTimeout();
+            });
             if (onTurnUsage) emitAssistantUsage(line.trim(), onTurnUsage);
             if (onAssistantText) emitAssistantTextEvents(line.trim(), onAssistantText);
           }
@@ -264,6 +299,8 @@ export const createClaudeService = ({ verbose = false, log: logFn }) => {
     logFn('CLAUDE', `Prompt written to stdin, waiting for ${label} to complete...`);
 
     child.on('close', code => {
+      if (postResultTimer) clearTimeout(postResultTimer);
+      if (sigkillTimer) clearTimeout(sigkillTimer);
       if (useStreamJson && lineBuf.trim()) {
         if (verbose) formatStreamEvent(lineBuf.trim(), tag);
         if (onToolUse) emitToolUseEvents(lineBuf.trim(), onToolUse);
@@ -271,9 +308,13 @@ export const createClaudeService = ({ verbose = false, log: logFn }) => {
         if (onAssistantText) emitAssistantTextEvents(lineBuf.trim(), onAssistantText);
         if (onTurnUsage) emitAssistantUsage(lineBuf.trim(), onTurnUsage);
       }
-      if (code === 0) {
+      if (code === 0 || killedByTimeout) {
         const result = useStreamJson ? extractResultText(stdout) : stdout;
-        logFn('CLAUDE', `${label} OK — result length: ${result.length} chars`);
+        if (killedByTimeout) {
+          logFn('CLAUDE', `${label} — process killed by post-result timeout, treating as success (result length: ${result.length} chars)`);
+        } else {
+          logFn('CLAUDE', `${label} OK — result length: ${result.length} chars`);
+        }
         resolve(result);
       } else {
         logFn('CLAUDE', `${label} FAIL exit=${code} stderr=${stderr.slice(0, 500).trim()}`);