@taskforcehq/taskforce 0.3.168

package/scripts/generate-workflow-templates.mjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { workflowDocs } from '../src/resources/templates/workflow-sources/workflowDocs.mjs';
+
+const ROOT = process.cwd();
+const OUT_DIR = path.join(ROOT, 'src/resources/templates/workflows');
+const OVERRIDES_PATH = path.join(ROOT, 'src/resources/templates/workflow-sources/workflowEditorOverrides.json');
+const CHECK_ONLY = process.argv.includes('--check');
+
+const dumpYaml = (doc) =>
+    yaml.dump(doc, {
+        noRefs: true,
+        lineWidth: -1,
+        quotingType: '"'
+    });
+
+const renderDoc = (doc) =>
+    dumpYaml({
+        version: 2,
+        name: doc.name,
+        description: doc.description,
+        type: 'workflow',
+        metadata: doc.metadata,
+        dispatch: doc.dispatch,
+        compat: doc.compat,
+        toolPolicy: doc.toolPolicy,
+        ...(doc.artifacts ? { artifacts: doc.artifacts } : {}),
+        contextPolicy: doc.contextPolicy,
+        prompts: doc.prompts,
+        content: doc.content
+    });
+
+const toList = (value) =>
+    String(value || '')
+        .split(/\n|,/)
+        .map((v) => v.trim())
+        .filter(Boolean);
+
+const applyOverride = (doc, override) => {
+    if (!override || typeof override !== 'object') return doc;
+
+    const next = JSON.parse(JSON.stringify(doc));
+
+    if (typeof override.description === 'string') {
+        next.description = override.description;
+    }
+    if (typeof override.aliasesText === 'string') {
+        const aliases = toList(override.aliasesText);
+        if (!next.dispatch) next.dispatch = {};
+        next.dispatch.aliases = aliases;
+    }
+    if (typeof override.dispatchDefault === 'string') {
+        if (!next.dispatch) next.dispatch = {};
+        next.dispatch.default = override.dispatchDefault.trim();
+    }
+    if (typeof override.criticalToolsText === 'string') {
+        const tools = toList(override.criticalToolsText);
+        if (!next.compat) next.compat = {};
+        next.compat.requiredToolsCritical = tools;
+    }
+    if (typeof override.optionalToolsText === 'string') {
+        const tools = toList(override.optionalToolsText);
+        if (!next.compat) next.compat = {};
+        next.compat.requiredToolsOptional = tools;
+    }
+    if (typeof override.contentDefault === 'string') {
+        if (!next.content) next.content = {};
+        next.content.default = override.contentDefault;
+    }
+
+    return next;
+};
+
+const overrides = (() => {
+    if (!fs.existsSync(OVERRIDES_PATH)) return {};
+    try {
+        return JSON.parse(fs.readFileSync(OVERRIDES_PATH, 'utf8') || '{}');
+    } catch (e) {
+        console.error(`Invalid workflow overrides JSON at ${OVERRIDES_PATH}`);
+        throw e;
+    }
+})();
+
+if (!fs.existsSync(OUT_DIR)) {
+    fs.mkdirSync(OUT_DIR, { recursive: true });
+}
+
+const effectiveDocs = workflowDocs.map((doc) => applyOverride(doc, overrides[doc.name]));
+
+const expectedNames = new Set(effectiveDocs.map((doc) => `${doc.name}.yaml`));
+const actualNames = fs.readdirSync(OUT_DIR).filter((file) => file.endsWith('.yaml'));
+
+const diffs = [];
+
+for (const doc of effectiveDocs) {
+    const outPath = path.join(OUT_DIR, `${doc.name}.yaml`);
+    const rendered = renderDoc(doc);
+
+    if (CHECK_ONLY) {
+        if (!fs.existsSync(outPath)) {
+            diffs.push(`missing: ${doc.name}.yaml`);
+            continue;
+        }
+
+        const existing = fs.readFileSync(outPath, 'utf8');
+        if (existing !== rendered) {
+            diffs.push(`outdated: ${doc.name}.yaml`);
+        }
+    } else {
+        fs.writeFileSync(outPath, rendered, 'utf8');
+    }
+}
+
+for (const filename of actualNames) {
+    if (!expectedNames.has(filename)) {
+        diffs.push(`unexpected: ${filename}`);
+    }
+}
+
+if (CHECK_ONLY) {
+    if (diffs.length > 0) {
+        console.error('Workflow template drift detected:');
+        for (const diff of diffs) console.error(`- ${diff}`);
+        console.error('Run `npm run gen:workflows` to regenerate templates.');
+        process.exit(1);
+    }
+
+    console.log(`Workflow templates are up to date (${effectiveDocs.length} files).`);
+} else {
+    console.log(`Generated ${effectiveDocs.length} workflow templates in ${OUT_DIR}`);
+}

package/scripts/mcp-stdio-adapter.mjs

@@ -0,0 +1,160 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+const projectRoot = process.argv[2] ? path.resolve(process.argv[2]) : process.cwd();
+const distServerPath = path.join(projectRoot, "dist/mcp/server.js");
+const childUsesContentLength = (() => {
+    try {
+        const source = fs.readFileSync(distServerPath, "utf8");
+        return source.includes("ContentLengthStdioServerTransport");
+    } catch {
+        return true;
+    }
+})();
+
+const child = spawn("node", ["dist/mcp/server.js", projectRoot], {
+    cwd: projectRoot,
+    stdio: ["pipe", "pipe", "pipe"],
+});
+
+child.stderr.on("data", (chunk) => {
+    process.stderr.write(chunk);
+});
+
+child.on("exit", (code, signal) => {
+    if (signal) {
+        process.stderr.write(`[mcp-adapter] child exited via signal ${signal}\n`);
+        process.exit(1);
+        return;
+    }
+    process.exit(code ?? 0);
+});
+
+child.on("error", (error) => {
+    process.stderr.write(`[mcp-adapter] child process error: ${error.message}\n`);
+    process.exit(1);
+});
+
+let inboundBuffer = Buffer.alloc(0);
+let clientFraming = null;
+
+const writeContentLengthFrame = (stream, line) => {
+    const header = `Content-Length: ${Buffer.byteLength(line, "utf8")}\r\n\r\n`;
+    stream.write(header + line);
+};
+
+const forwardToChild = (json) => {
+    if (childUsesContentLength) {
+        writeContentLengthFrame(child.stdin, json);
+        return;
+    }
+    child.stdin.write(json + "\n");
+};
+
+const tryParseInbound = () => {
+    while (inboundBuffer.length > 0) {
+        const contentLengthPrefix = "Content-Length:";
+        const head = inboundBuffer.toString("utf8", 0, Math.min(inboundBuffer.length, contentLengthPrefix.length));
+        const maybeContentLength = contentLengthPrefix.startsWith(head);
+        const startsWithContentLength = inboundBuffer.length >= contentLengthPrefix.length && inboundBuffer.toString("utf8", 0, contentLengthPrefix.length) === contentLengthPrefix;
+
+        if (maybeContentLength && !startsWithContentLength) {
+            return;
+        }
+
+        if (startsWithContentLength) {
+            clientFraming = clientFraming ?? "content-length";
+            const headerEnd = inboundBuffer.indexOf("\r\n\r\n");
+            if (headerEnd === -1) return;
+
+            const headerText = inboundBuffer.toString("utf8", 0, headerEnd);
+            const match = headerText.match(/(?:^|\r\n)Content-Length:\s*(\d+)\s*(?:\r\n|$)/i);
+            if (!match) {
+                inboundBuffer = Buffer.alloc(0);
+                return;
+            }
+
+            const bodyLength = Number(match[1]);
+            const bodyStart = headerEnd + 4;
+            const bodyEnd = bodyStart + bodyLength;
+            if (inboundBuffer.length < bodyEnd) return;
+
+            const body = inboundBuffer.toString("utf8", bodyStart, bodyEnd);
+            inboundBuffer = inboundBuffer.subarray(bodyEnd);
+            forwardToChild(body);
+            continue;
+        }
+
+        const newlineIndex = inboundBuffer.indexOf("\n");
+        if (newlineIndex === -1) return;
+
+        const line = inboundBuffer.toString("utf8", 0, newlineIndex).replace(/\r$/, "").trim();
+        inboundBuffer = inboundBuffer.subarray(newlineIndex + 1);
+        if (line) {
+            clientFraming = clientFraming ?? "newline";
+            forwardToChild(line);
+        }
+    }
+};
+
+process.stdin.on("data", (chunk) => {
+    inboundBuffer = inboundBuffer.length ? Buffer.concat([inboundBuffer, chunk]) : chunk;
+    tryParseInbound();
+});
+
+process.stdin.on("end", () => {
+    child.stdin.end();
+});
+
+let childOutBuffer = "";
+let childOutBinaryBuffer = Buffer.alloc(0);
+
+child.stdout.on("data", (chunk) => {
+    if (childUsesContentLength) {
+        childOutBinaryBuffer = childOutBinaryBuffer.length ? Buffer.concat([childOutBinaryBuffer, chunk]) : chunk;
+
+        while (true) {
+            const headerEnd = childOutBinaryBuffer.indexOf("\r\n\r\n");
+            if (headerEnd === -1) break;
+
+            const headerText = childOutBinaryBuffer.toString("utf8", 0, headerEnd);
+            const match = headerText.match(/(?:^|\r\n)Content-Length:\s*(\d+)\s*(?:\r\n|$)/i);
+            if (!match) {
+                childOutBinaryBuffer = Buffer.alloc(0);
+                break;
+            }
+
+            const bodyLength = Number(match[1]);
+            const bodyStart = headerEnd + 4;
+            const bodyEnd = bodyStart + bodyLength;
+            if (childOutBinaryBuffer.length < bodyEnd) break;
+
+            const body = childOutBinaryBuffer.toString("utf8", bodyStart, bodyEnd);
+            childOutBinaryBuffer = childOutBinaryBuffer.subarray(bodyEnd);
+
+            if (clientFraming === "newline") {
+                process.stdout.write(body + "\n");
+            } else {
+                writeContentLengthFrame(process.stdout, body);
+            }
+        }
+        return;
+    }
+
+    childOutBuffer += chunk.toString("utf8");
+    while (true) {
+        const newlineIndex = childOutBuffer.indexOf("\n");
+        if (newlineIndex === -1) break;
+
+        const line = childOutBuffer.slice(0, newlineIndex).replace(/\r$/, "").trim();
+        childOutBuffer = childOutBuffer.slice(newlineIndex + 1);
+        if (!line) continue;
+
+        if (clientFraming === "newline") {
+            process.stdout.write(line + "\n");
+        } else {
+            writeContentLengthFrame(process.stdout, line);
+        }
+    }
+});

package/scripts/postinstall.js

@@ -0,0 +1,60 @@
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+try {
+    // 1. Get our own version reliably
+    let version = '';
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+        version = pkg.version;
+    } catch (e) {
+        version = process.env.npm_package_version || '';
+    }
+
+    const versionStr = version ? ` v${version}` : '';
+    console.log(`\n\x1b[35m[Taskforce]${versionStr} installed successfully!\x1b[0m`);
+    
+    // 2. Try to find the project root to check for correct dependency type
+    let projectRoot = process.env.INIT_CWD;
+    
+    // If INIT_CWD is not set or doesn't have a package.json, try traversing up
+    if (!projectRoot || !existsSync(join(projectRoot, 'package.json'))) {
+        let current = __dirname;
+        // Traverse up to find project root (looking for a package.json that isn't ours)
+        for (let i = 0; i < 6; i++) {
+            const pkgPath = join(current, 'package.json');
+            if (existsSync(pkgPath)) {
+                try {
+                    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+                    if (pkg.name !== '@taskforcehq/taskforce' && pkg.name !== 'taskforce') {
+                        projectRoot = current;
+                        break;
+                    }
+                } catch (e) { /* ignore parse error */ }
+            }
+            const parent = dirname(current);
+            if (parent === current) break;
+            current = parent;
+        }
+    }
+
+    if (projectRoot) {
+        try {
+            const projectPkg = JSON.parse(readFileSync(join(projectRoot, 'package.json'), 'utf-8'));
+            if (projectPkg.dependencies && projectPkg.dependencies.taskforce) {
+                console.log('\x1b[33m\n⚠️  [Taskforce] Warning: Installed as a regular dependency.\x1b[0m');
+                console.log('\x1b[33m   Taskforce should be installed globally.\x1b[0m');
+                console.log('   Run: \x1b[36mnpm install -g @taskforcehq/taskforce\x1b[0m to fix this.\n');
+            }
+        } catch (err) {
+            // Ignore errors checking project package.json
+        }
+    }
+
+    console.log(`Run \x1b[36mnpx @taskforcehq/taskforce open\x1b[0m to manage your tasks.\n`);
+} catch (e) {
+    // Silent fail to avoid breaking install
+}

package/scripts/release-version-lib.mjs

@@ -0,0 +1,88 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export function parseVersionTriplet(version) {
+    const raw = String(version || '').trim();
+    const match = raw.match(/^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
+    if (!match) return null;
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3])
+    };
+}
+
+export function parseReleaseTag(tag) {
+    const raw = String(tag || '').trim();
+    const match = raw.match(/^v(\d+)\.(\d+)\.(\d+)$/);
+    if (!match) return null;
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3])
+    };
+}
+
+export function readVersionConfig(projectRoot) {
+    const configPath = path.resolve(projectRoot, 'version.config.json');
+    const raw = fs.readFileSync(configPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    const major = Number(parsed?.major);
+    const minor = Number(parsed?.minor);
+    if (!Number.isInteger(major) || major < 0) {
+        throw new Error(`version.config.json major must be a non-negative integer (got: ${parsed?.major})`);
+    }
+    if (!Number.isInteger(minor) || minor < 0) {
+        throw new Error(`version.config.json minor must be a non-negative integer (got: ${parsed?.minor})`);
+    }
+    return {
+        major,
+        minor,
+        path: configPath
+    };
+}
+
+export function readPackageVersion(projectRoot) {
+    const packagePath = path.resolve(projectRoot, 'package.json');
+    const raw = fs.readFileSync(packagePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return String(parsed?.version || '').trim();
+}
+
+export function computeNextPatch({
+    major,
+    minor,
+    releaseTags,
+    currentPackageVersion
+}) {
+    const patches = (releaseTags || [])
+        .map(parseReleaseTag)
+        .filter(tag => tag && tag.major === major && tag.minor === minor)
+        .map(tag => tag.patch);
+
+    if (patches.length > 0) {
+        return Math.max(...patches) + 1;
+    }
+
+    const packageParsed = parseVersionTriplet(currentPackageVersion);
+    if (packageParsed && packageParsed.major === major && packageParsed.minor === minor) {
+        return packageParsed.patch + 1;
+    }
+
+    return 0;
+}
+
+export function computeNextVersion({
+    major,
+    minor,
+    releaseTags,
+    currentPackageVersion
+}) {
+    const nextPatch = computeNextPatch({
+        major,
+        minor,
+        releaseTags,
+        currentPackageVersion
+    });
+    return `${major}.${minor}.${nextPatch}`;
+}

package/scripts/release-version.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+import { execFileSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+    computeNextVersion,
+    readPackageVersion,
+    readVersionConfig
+} from './release-version-lib.mjs';
+
+function hasArg(name) {
+    return process.argv.includes(name);
+}
+
+function readReleaseTags(projectRoot) {
+    const output = execFileSync('git', ['tag', '--list', 'v*'], {
+        cwd: projectRoot,
+        encoding: 'utf8'
+    });
+    return output
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean);
+}
+
+function writeGithubOutput(key, value) {
+    const outputPath = String(process.env.GITHUB_OUTPUT || '').trim();
+    if (!outputPath) return;
+    fs.appendFileSync(outputPath, `${key}=${value}\n`, 'utf8');
+}
+
+function main() {
+    const projectRoot = process.cwd();
+    const dryRun = hasArg('--dry-run');
+    const json = hasArg('--json');
+
+    const { major, minor, path: configPath } = readVersionConfig(projectRoot);
+    const currentPackageVersion = readPackageVersion(projectRoot);
+    const releaseTags = readReleaseTags(projectRoot);
+    const nextVersion = computeNextVersion({
+        major,
+        minor,
+        releaseTags,
+        currentPackageVersion
+    });
+
+    writeGithubOutput('version', nextVersion);
+
+    if (json) {
+        console.log(JSON.stringify({
+            configPath: path.relative(projectRoot, configPath),
+            currentPackageVersion,
+            nextVersion,
+            dryRun
+        }));
+    } else {
+        console.log(`Next release version: ${nextVersion}`);
+        if (dryRun) {
+            console.log('Dry run enabled. package.json was not modified.');
+        }
+    }
+
+    if (dryRun) return;
+
+    execFileSync('npm', ['version', '--no-git-tag-version', nextVersion], {
+        cwd: projectRoot,
+        stdio: 'inherit'
+    });
+}
+
+main();

package/scripts/run-dev-proxy.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env sh
+set -eu
+
+target="${1:-}"
+if [ -z "$target" ]; then
+  echo "Usage: sh scripts/run-dev-proxy.sh <staging|performance>" >&2
+  exit 1
+fi
+
+case "$target" in
+  staging)
+    base_url="https://staging-app.taskforcehq.ai"
+    ;;
+  performance)
+    base_url="https://performance-app.taskforcehq.ai"
+    ;;
+  *)
+    echo "Invalid target: $target (expected staging or performance)" >&2
+    exit 1
+    ;;
+esac
+
+env_file=""
+for candidate in ".env.${target}" ".env.e2e" ".env.local"; do
+  if [ -f "$candidate" ]; then
+    env_file="$candidate"
+    break
+  fi
+done
+
+if [ -n "$env_file" ]; then
+  set -a
+  # shellcheck disable=SC1090
+  . "$env_file"
+  set +a
+fi
+
+client_id="${TASKFORCE_CF_ACCESS_CLIENT_ID:-${CF_ACCESS_CLIENT_ID:-}}"
+client_secret="${TASKFORCE_CF_ACCESS_CLIENT_SECRET:-${CF_ACCESS_CLIENT_SECRET:-}}"
+if [ -z "${client_id}" ] || [ -z "${client_secret}" ]; then
+  echo "Missing Cloudflare Access service token variables." >&2
+  echo "Set TASKFORCE_CF_ACCESS_CLIENT_ID/TASKFORCE_CF_ACCESS_CLIENT_SECRET" >&2
+  echo "or CF_ACCESS_CLIENT_ID/CF_ACCESS_CLIENT_SECRET in .env.${target}, .env.e2e, or .env.local." >&2
+  exit 1
+fi
+
+VITE_TASKFORCE_BASE_URL="$base_url" \
+TASKFORCE_CLOUD_PROXY_BASE_URL="$base_url" \
+npm run dev:runtime

package/scripts/run-e2e-realtime.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+set -eu
+
+if [ -f .env.e2e ]; then
+  set -a
+  . ./.env.e2e
+  set +a
+fi
+
+# Mirror soak defaults so realtime e2e runs are plug-compatible with existing env setup.
+export SYNC_SOAK_LOCAL_BASE_URL="${SYNC_SOAK_LOCAL_BASE_URL:-http://localhost:5174}"
+export SYNC_SOAK_CLOUD_BASE_URL="${SYNC_SOAK_CLOUD_BASE_URL:-https://performance-app.taskforcehq.ai}"
+export SYNC_SOAK_WORKSPACE_ID="${SYNC_SOAK_WORKSPACE_ID:-test-smoke}"
+
+node --import tsx scripts/check-env.ts --target=soak --strict=true
+npx playwright test -c playwright.e2e.config.ts "$@"

package/scripts/run-smoke.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+set -eu
+
+if [ -f .env.e2e ]; then
+  set -a
+  . ./.env.e2e
+  set +a
+fi
+
+# Provide safe defaults for non-secret settings; allow caller/.env.e2e overrides.
+export SYNC_SOAK_LOCAL_BASE_URL="${SYNC_SOAK_LOCAL_BASE_URL:-http://localhost:5174}"
+export SYNC_SOAK_CLOUD_BASE_URL="${SYNC_SOAK_CLOUD_BASE_URL:-https://performance-app.taskforcehq.ai}"
+export SYNC_SOAK_WORKSPACE_ID="${SYNC_SOAK_WORKSPACE_ID:-test-smoke}"
+
+node --import tsx scripts/check-env.ts --target=soak --strict=true
+
+# Shared credentials are required and must come from env/.env.e2e.
+if [ -z "${SYNC_SOAK_ACCOUNTS_JSON:-}" ] && { [ -z "${SYNC_SOAK_EMAIL:-}" ] || [ -z "${SYNC_SOAK_PASSWORD:-}" ]; }; then
+  echo "Missing credentials. Set SYNC_SOAK_ACCOUNTS_JSON or SYNC_SOAK_EMAIL+SYNC_SOAK_PASSWORD in env/.env.e2e." >&2
+  exit 1
+fi
+
+npx playwright test -c playwright.smoke.config.ts "$@"

package/scripts/run-soak.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+set -eu
+
+if [ -f .env.e2e ]; then
+  set -a
+  . ./.env.e2e
+  set +a
+fi
+
+# Provide safe defaults for non-secret settings; allow caller/.env.e2e overrides.
+# Soak runs target the dedicated performance cloud by default.
+export SYNC_SOAK_LOCAL_BASE_URL="${SYNC_SOAK_LOCAL_BASE_URL:-http://localhost:5174}"
+export SYNC_SOAK_CLOUD_BASE_URL="${SYNC_SOAK_CLOUD_BASE_URL:-https://performance-app.taskforcehq.ai}"
+export SYNC_SOAK_WORKSPACE_ID="${SYNC_SOAK_WORKSPACE_ID:-test-smoke}"
+
+node --import tsx scripts/check-env.ts --target=soak --strict=true
+
+# Shared credentials are required and must come from env/.env.e2e.
+if [ -z "${SYNC_SOAK_ACCOUNTS_JSON:-}" ] && { [ -z "${SYNC_SOAK_EMAIL:-}" ] || [ -z "${SYNC_SOAK_PASSWORD:-}" ]; }; then
+  echo "Missing credentials. Set SYNC_SOAK_ACCOUNTS_JSON or SYNC_SOAK_EMAIL+SYNC_SOAK_PASSWORD in env/.env.e2e." >&2
+  exit 1
+fi
+
+if [ "${SOAK_BUILD_UI:-true}" = "true" ]; then
+  echo "[Soak] Rebuilding full dist bundle before soak run (SOAK_BUILD_UI=true)"
+  npm run -s build
+fi
+
+npx playwright test -c playwright.smoke.config.ts "$@"