@assistkick/create 1.18.0 → 1.21.0

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

@@ -8,6 +8,13 @@
       "when": 1773826299804,
       "tag": "0000_outgoing_ultron",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "6",
+      "when": 1773914724031,
+      "tag": "0001_superb_roxanne_simpson",
+      "breakpoints": true
     }
   ]
 }

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

@@ -247,6 +247,16 @@ export const workflowToolCalls = sqliteTable('workflow_tool_calls', {
   createdAt: text('created_at').notNull(),
 });
 
+// --- user_mcp_configs table ---
+export const userMcpConfigs = sqliteTable('user_mcp_configs', {
+  id: text('id').primaryKey(),
+  userId: text('user_id').notNull(),
+  configType: text('config_type').notNull(), // 'localhost' or 'remote'
+  mcpServersJson: text('mcp_servers_json').notNull().default('{}'),
+  createdAt: text('created_at').notNull(),
+  updatedAt: text('updated_at').notNull(),
+});
+
 // --- chat_permission_rules table ---
 export const chatPermissionRules = sqliteTable('chat_permission_rules', {
   id: text('id').primaryKey(),

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

@@ -0,0 +1,484 @@
+/**
+ * app_use_flow — Shared types and utilities for the app-use flow YAML format.
+ *
+ * A flow file is a YAML document with an optional header (config) separated
+ * from steps by `---`. Steps are a list of actions that map to agent-browser
+ * commands (for web) or platform-specific commands (for iOS/Android).
+ */
+
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+
+export type Platform = 'web' | 'ios' | 'android';
+
+export interface FlowConfig {
+  /** App URL (web) or bundle ID (mobile) */
+  appId?: string;
+  /** Target platform */
+  platform?: Platform;
+  /** Display name for the flow */
+  name?: string;
+  /** Environment variables for interpolation */
+  env?: Record<string, string>;
+  /** Whether to manage agent-browser session automatically */
+  autoSession?: boolean;
+  /** Tags for filtering */
+  tags?: string[];
+}
+
+export type StepType =
+  | 'open' | 'click' | 'dblclick' | 'fill' | 'type' | 'press'
+  | 'hover' | 'select' | 'check' | 'uncheck'
+  | 'scroll' | 'scrollIntoView'
+  | 'wait' | 'snapshot' | 'screenshot'
+  | 'assertVisible' | 'assertNotVisible' | 'assertUrl' | 'assertText' | 'assertWithAI'
+  | 'back' | 'forward' | 'reload'
+  | 'eval' | 'setViewport' | 'setDevice'
+  | 'upload' | 'drag'
+  | 'tab' | 'frame'
+  | 'sessionStart' | 'sessionEnd';
+
+export interface FlowStep {
+  /** Action type */
+  type: StepType;
+  /** Main argument (shorthand for the primary parameter) */
+  value?: string;
+  /** Element selector (ref @e1, CSS #id, text=..., etc.) */
+  selector?: string;
+  /** Additional parameters (type-specific) */
+  params?: Record<string, unknown>;
+  /** Human-readable label for this step */
+  label?: string;
+  /** If true, step failure doesn't abort the flow */
+  optional?: boolean;
+}
+
+export interface FlowFile {
+  config: FlowConfig;
+  steps: FlowStep[];
+}
+
+export interface StepResult {
+  step: FlowStep;
+  index: number;
+  status: 'passed' | 'failed' | 'skipped';
+  durationMs: number;
+  output?: string;
+  error?: string;
+}
+
+export interface FlowResult {
+  flowName: string;
+  platform: Platform;
+  status: 'passed' | 'failed';
+  totalSteps: number;
+  passed: number;
+  failed: number;
+  skipped: number;
+  durationMs: number;
+  steps: StepResult[];
+}
+
+// ── Parsing ───────────────────────────────────────────────────────────────────
+
+/**
+ * Parse a raw YAML step into a normalized FlowStep.
+ * Supports both shorthand (`- click: "@e1"`) and full object form.
+ */
+function parseStep(raw: unknown): FlowStep | null {
+  if (typeof raw === 'string') {
+    // Simple command with no args: `- back`, `- reload`
+    return { type: raw as StepType };
+  }
+
+  if (typeof raw !== 'object' || raw === null) return null;
+  const obj = raw as Record<string, unknown>;
+
+  // Find the action key (first key that is a valid step type)
+  const keys = Object.keys(obj);
+  const typeKey = keys[0];
+  if (!typeKey) return null;
+
+  const step: FlowStep = { type: typeKey as StepType };
+
+  const val = obj[typeKey];
+
+  if (typeof val === 'string' || typeof val === 'number') {
+    // Shorthand: `- click: "@e1"` or `- wait: 2000`
+    step.value = String(val);
+  } else if (typeof val === 'object' && val !== null && !Array.isArray(val)) {
+    // Full object form
+    const params = val as Record<string, unknown>;
+    if (params.selector !== undefined) step.selector = String(params.selector);
+    if (params.value !== undefined) step.value = String(params.value);
+    if (params.label !== undefined) step.label = String(params.label);
+    if (params.optional !== undefined) step.optional = Boolean(params.optional);
+
+    // Remaining keys go into params
+    const rest: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(params)) {
+      if (!['selector', 'value', 'label', 'optional'].includes(k)) {
+        rest[k] = v;
+      }
+    }
+    if (Object.keys(rest).length > 0) step.params = rest;
+  }
+
+  // Also pick up top-level label/optional
+  if (obj.label !== undefined) step.label = String(obj.label);
+  if (obj.optional !== undefined) step.optional = Boolean(obj.optional);
+
+  return step;
+}
+
+/**
+ * Parse a flow YAML string into a FlowFile.
+ * Handles the `---` separator between config header and steps.
+ */
+export function parseFlowYaml(content: string): FlowFile {
+  // Split on document separator
+  const parts = content.split(/^---\s*$/m);
+
+  let config: FlowConfig = {};
+  let stepsRaw: unknown[] = [];
+
+  if (parts.length >= 2) {
+    // Header + steps
+    const headerPart = parts[0].trim();
+    const stepsPart = parts.slice(1).join('---').trim();
+
+    if (headerPart) {
+      config = (parseYaml(headerPart) as FlowConfig) || {};
+    }
+    if (stepsPart) {
+      stepsRaw = (parseYaml(stepsPart) as unknown[]) || [];
+    }
+  } else {
+    // No separator — treat as steps only, or check if it's an array
+    const parsed = parseYaml(content);
+    if (Array.isArray(parsed)) {
+      stepsRaw = parsed;
+    } else if (typeof parsed === 'object' && parsed !== null) {
+      // Could be a config-only document
+      config = parsed as FlowConfig;
+    }
+  }
+
+  const steps = (stepsRaw || [])
+    .map(parseStep)
+    .filter((s): s is FlowStep => s !== null);
+
+  // Defaults
+  if (!config.platform) config.platform = 'web';
+  if (config.autoSession === undefined) config.autoSession = true;
+
+  return { config, steps };
+}
+
+/**
+ * Read and parse a flow YAML file.
+ */
+export function readFlowFile(path: string): FlowFile {
+  if (!existsSync(path)) {
+    throw new Error(`Flow file not found: ${path}`);
+  }
+  const content = readFileSync(path, 'utf-8');
+  return parseFlowYaml(content);
+}
+
+// ── Serialization ─────────────────────────────────────────────────────────────
+
+/**
+ * Serialize a FlowStep back to a YAML-friendly plain object.
+ */
+function stepToYamlObj(step: FlowStep): Record<string, unknown> {
+  const hasExtra = step.selector || step.params || step.label || step.optional;
+
+  if (!hasExtra && step.value) {
+    // Shorthand form
+    return { [step.type]: step.value };
+  }
+
+  if (!hasExtra && !step.value) {
+    // Bare command
+    return { [step.type]: null };
+  }
+
+  // Full object form
+  const inner: Record<string, unknown> = {};
+  if (step.selector) inner.selector = step.selector;
+  if (step.value) inner.value = step.value;
+  if (step.label) inner.label = step.label;
+  if (step.optional) inner.optional = step.optional;
+  if (step.params) Object.assign(inner, step.params);
+
+  return { [step.type]: inner };
+}
+
+/**
+ * Serialize a FlowFile to YAML string.
+ */
+export function serializeFlowYaml(flow: FlowFile, comments?: string[]): string {
+  const parts: string[] = [];
+
+  // Config header
+  const configCopy = { ...flow.config };
+  if (configCopy.autoSession === true) delete configCopy.autoSession; // default
+  const hasConfig = Object.keys(configCopy).length > 0;
+
+  if (hasConfig) {
+    parts.push(stringifyYaml(configCopy).trim());
+  }
+
+  parts.push('---');
+
+  // Comments
+  if (comments && comments.length > 0) {
+    for (const c of comments) {
+      parts.push(`# ${c}`);
+    }
+  }
+
+  // Steps
+  const stepsObj = flow.steps.map(stepToYamlObj);
+  parts.push(stringifyYaml(stepsObj).trim());
+
+  return parts.join('\n') + '\n';
+}
+
+/**
+ * Write a flow file to disk.
+ */
+export function writeFlowFile(path: string, flow: FlowFile, comments?: string[]): void {
+  const dir = dirname(path);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(path, serializeFlowYaml(flow, comments), 'utf-8');
+}
+
+// ── Interpolation ─────────────────────────────────────────────────────────────
+
+/**
+ * Interpolate `${VAR}` references in a string using the env map.
+ */
+export function interpolate(text: string, env: Record<string, string>): string {
+  return text.replace(/\$\{(\w+)\}/g, (_, key) => env[key] ?? `\${${key}}`);
+}
+
+// ── Step → agent-browser command mapping ──────────────────────────────────────
+
+/**
+ * Translate a FlowStep to an agent-browser CLI command (for web platform).
+ * Returns the command as a string array (args to pass to agent-browser).
+ */
+export function stepToAgentBrowserArgs(step: FlowStep, env: Record<string, string> = {}): string[] {
+  const val = step.value ? interpolate(step.value, env) : '';
+  const sel = step.selector ? interpolate(step.selector, env) : '';
+
+  switch (step.type) {
+    case 'open':
+      return ['open', val];
+
+    case 'click':
+      return ['click', sel || val];
+
+    case 'dblclick':
+      return ['dblclick', sel || val];
+
+    case 'fill':
+      return ['fill', sel, val];
+
+    case 'type':
+      return ['type', sel, val];
+
+    case 'press':
+      return ['press', val];
+
+    case 'hover':
+      return ['hover', sel || val];
+
+    case 'select':
+      return ['select', sel, val];
+
+    case 'check':
+      return ['check', sel || val];
+
+    case 'uncheck':
+      return ['uncheck', sel || val];
+
+    case 'scroll': {
+      const dir = val || 'down';
+      const args = ['scroll', dir];
+      if (step.params?.pixels) args.push(String(step.params.pixels));
+      if (step.params?.selector) args.push('--selector', String(step.params.selector));
+      return args;
+    }
+
+    case 'scrollIntoView':
+      return ['scrollintoview', sel || val];
+
+    case 'wait': {
+      if (step.params?.text) return ['wait', '--text', String(step.params.text)];
+      if (step.params?.url) return ['wait', '--url', String(step.params.url)];
+      if (step.params?.load) return ['wait', '--load', String(step.params.load)];
+      if (step.params?.fn) return ['wait', '--fn', String(step.params.fn)];
+      // Numeric wait (ms) or selector wait
+      if (val && /^\d+$/.test(val)) return ['wait', val];
+      if (val) return ['wait', val];
+      return ['wait', '1000'];
+    }
+
+    case 'snapshot': {
+      const args = ['snapshot'];
+      if (step.params?.interactive !== false) args.push('-i');
+      if (step.params?.compact) args.push('-c');
+      if (step.params?.depth) args.push('-d', String(step.params.depth));
+      if (step.params?.selector) args.push('-s', String(step.params.selector));
+      return args;
+    }
+
+    case 'screenshot': {
+      const args = ['screenshot'];
+      if (val) args.push(val);
+      if (step.params?.full) args.push('--full');
+      if (step.params?.annotate) args.push('--annotate');
+      return args;
+    }
+
+    case 'assertVisible':
+      // Implemented via snapshot + check (handled at runner level)
+      return ['snapshot', '-i', '--json'];
+
+    case 'assertNotVisible':
+      return ['snapshot', '-i', '--json'];
+
+    case 'assertUrl':
+      return ['get', 'url'];
+
+    case 'assertText':
+      return ['get', 'text', sel];
+
+    case 'assertWithAI':
+      // Screenshot for AI analysis (handled at runner level)
+      return ['screenshot'];
+
+    case 'back':
+      return ['back'];
+
+    case 'forward':
+      return ['forward'];
+
+    case 'reload':
+      return ['reload'];
+
+    case 'eval':
+      return ['eval', val];
+
+    case 'setViewport': {
+      const w = step.params?.width || 1280;
+      const h = step.params?.height || 720;
+      return ['set', 'viewport', String(w), String(h)];
+    }
+
+    case 'setDevice':
+      return ['set', 'device', val];
+
+    case 'upload':
+      return ['upload', sel, val];
+
+    case 'drag': {
+      const target = step.params?.target ? String(step.params.target) : '';
+      return ['drag', sel || val, target];
+    }
+
+    case 'tab': {
+      if (step.params?.action === 'new') return ['tab', 'new', val].filter(Boolean);
+      if (step.params?.action === 'close') return ['tab', 'close', val].filter(Boolean);
+      return ['tab', val].filter(Boolean);
+    }
+
+    case 'frame':
+      return val === 'main' ? ['frame', 'main'] : ['frame', sel || val];
+
+    case 'sessionStart':
+      return ['open', val || 'about:blank'];
+
+    case 'sessionEnd':
+      return ['close'];
+
+    default:
+      throw new Error(`Unknown step type: ${step.type}`);
+  }
+}
+
+// ── Validation ────────────────────────────────────────────────────────────────
+
+const VALID_STEP_TYPES: Set<string> = new Set([
+  'open', 'click', 'dblclick', 'fill', 'type', 'press',
+  'hover', 'select', 'check', 'uncheck',
+  'scroll', 'scrollIntoView',
+  'wait', 'snapshot', 'screenshot',
+  'assertVisible', 'assertNotVisible', 'assertUrl', 'assertText', 'assertWithAI',
+  'back', 'forward', 'reload',
+  'eval', 'setViewport', 'setDevice',
+  'upload', 'drag',
+  'tab', 'frame',
+  'sessionStart', 'sessionEnd',
+]);
+
+const REQUIRES_SELECTOR: Set<string> = new Set([
+  'fill', 'type', 'assertText',
+]);
+
+const REQUIRES_VALUE: Set<string> = new Set([
+  'open', 'press', 'eval',
+]);
+
+/**
+ * Validate a parsed flow and return a list of issues.
+ */
+export function validateFlow(flow: FlowFile): string[] {
+  const issues: string[] = [];
+
+  if (flow.config.platform && !['web', 'ios', 'android'].includes(flow.config.platform)) {
+    issues.push(`Invalid platform: "${flow.config.platform}". Must be web, ios, or android`);
+  }
+
+  if (flow.steps.length === 0) {
+    issues.push('Flow has no steps');
+  }
+
+  for (let i = 0; i < flow.steps.length; i++) {
+    const step = flow.steps[i];
+    const prefix = `Step ${i + 1}`;
+
+    if (!VALID_STEP_TYPES.has(step.type)) {
+      issues.push(`${prefix}: unknown type "${step.type}"`);
+      continue;
+    }
+
+    if (REQUIRES_VALUE.has(step.type) && !step.value) {
+      issues.push(`${prefix} (${step.type}): missing required value`);
+    }
+
+    if (REQUIRES_SELECTOR.has(step.type) && !step.selector) {
+      issues.push(`${prefix} (${step.type}): missing required selector`);
+    }
+
+    // fill and type need both selector and value
+    if ((step.type === 'fill' || step.type === 'type') && !step.value) {
+      issues.push(`${prefix} (${step.type}): missing required value`);
+    }
+
+    // click/hover need either selector or value
+    if (['click', 'dblclick', 'hover', 'check', 'uncheck', 'scrollIntoView'].includes(step.type)) {
+      if (!step.selector && !step.value) {
+        issues.push(`${prefix} (${step.type}): missing selector or value`);
+      }
+    }
+  }
+
+  return issues;
+}

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

@@ -0,0 +1,146 @@
+/**
+ * Shared helper to load an OpenAPI spec from a local path or URL.
+ *
+ * If the source is a URL, the spec is downloaded into a local cache
+ * directory and reused for the rest of the current day.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CACHE_DIR = join(__dirname, '..', '..', '..', '..', '.claude', 'skills', 'assistkick-openapi-explorer', 'cache');
+
+function isUrl(source: string): boolean {
+  return source.startsWith('http://') || source.startsWith('https://');
+}
+
+function urlToCachePath(url: string): string {
+  const parsed = new URL(url);
+  const safeName = (parsed.host + parsed.pathname).replace(/[^a-zA-Z0-9._-]/g, '_');
+  const today = new Date().toISOString().slice(0, 10);
+  return join(CACHE_DIR, `${safeName}_${today}.json`);
+}
+
+async function download(url: string, dest: string): Promise<void> {
+  const res = await fetch(url, {
+    headers: { 'User-Agent': 'openapi-explorer/1.0' },
+    signal: AbortSignal.timeout(30_000),
+  });
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status} ${res.statusText}`);
+  }
+  const body = await res.text();
+  const dir = dirname(dest);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(dest, body, 'utf-8');
+}
+
+/**
+ * Load an OpenAPI spec from a local file path or URL.
+ * URLs are cached locally per day — a fresh download happens only once per day.
+ */
+export async function loadSpec(source: string): Promise<Record<string, any>> {
+  let path: string;
+
+  if (isUrl(source)) {
+    const cached = urlToCachePath(source);
+    if (!existsSync(cached)) {
+      await download(source, cached);
+    }
+    path = cached;
+  } else {
+    path = source;
+  }
+
+  if (!existsSync(path)) {
+    throw new Error(`Spec file not found: ${path}`);
+  }
+
+  const raw = readFileSync(path, 'utf-8');
+  return JSON.parse(raw);
+}
+
+/**
+ * Resolve a JSON Pointer $ref (e.g. "#/components/schemas/User") to its value in the spec.
+ */
+export function resolveRef(spec: Record<string, any>, ref: string): any {
+  const parts = ref.replace(/^#\//, '').split('/');
+  let obj: any = spec;
+  for (const part of parts) {
+    obj = obj[part];
+    if (obj === undefined) {
+      throw new Error(`Cannot resolve $ref: ${ref}`);
+    }
+  }
+  return obj;
+}
+
+/**
+ * Recursively inline $ref references up to a depth limit.
+ * Adds a __schema__ key to indicate which schema each inlined object represents.
+ */
+export function inlineRefs(spec: Record<string, any>, obj: any, depth = 0): any {
+  if (depth > 5) return obj;
+
+  if (Array.isArray(obj)) {
+    return obj.map(item => inlineRefs(spec, item, depth + 1));
+  }
+
+  if (obj !== null && typeof obj === 'object') {
+    if ('$ref' in obj) {
+      const refName = (obj['$ref'] as string).split('/').pop()!;
+      const resolved = resolveRef(spec, obj['$ref']);
+      return { __schema__: refName, ...inlineRefs(spec, resolved, depth + 1) };
+    }
+    const result: Record<string, any> = {};
+    for (const [k, v] of Object.entries(obj)) {
+      result[k] = inlineRefs(spec, v, depth + 1);
+    }
+    return result;
+  }
+
+  return obj;
+}
+
+/**
+ * Recursively collect all $ref strings from an object.
+ */
+export function collectRefs(obj: any, refs: Set<string> = new Set()): Set<string> {
+  if (Array.isArray(obj)) {
+    for (const item of obj) collectRefs(item, refs);
+  } else if (obj !== null && typeof obj === 'object') {
+    if ('$ref' in obj) refs.add(obj['$ref'] as string);
+    for (const v of Object.values(obj)) collectRefs(v, refs);
+  }
+  return refs;
+}
+
+/**
+ * Resolve a named schema and all its nested $ref dependencies.
+ * Returns a map of schema name → schema definition.
+ */
+export function resolveSchemaTree(
+  spec: Record<string, any>,
+  schemaName: string,
+  visited: Record<string, any> = {},
+): Record<string, any> {
+  if (schemaName in visited) return visited;
+
+  const schemas = spec?.components?.schemas ?? {};
+  if (!(schemaName in schemas)) return visited;
+
+  const schema = schemas[schemaName];
+  visited[schemaName] = schema;
+
+  const refs = collectRefs(schema);
+  for (const ref of refs) {
+    const childName = ref.split('/').pop()!;
+    if (!(childName in visited)) {
+      resolveSchemaTree(spec, childName, visited);
+    }
+  }
+
+  return visited;
+}

package/templates/assistkick-product-system/packages/shared/package.json

@@ -20,7 +20,8 @@
     "drizzle-orm": "^0.45.1",
     "glob": "11.1.0",
     "gray-matter": "^4.0.3",
-    "isolated-vm": "^6.1.0"
+    "isolated-vm": "^6.1.0",
+    "yaml": "^2.8.2"
   },
   "devDependencies": {
     "@types/node": "^25.3.3",