draftgo-cli 3.0.48 → 3.0.51

package/src/commands/conflict.js

@@ -18,9 +18,11 @@ async function conflict(projectDir, positional, flags = {}) {
     log.err('Usage: draftgo conflict <show|resolve> <pages|nav|docs> <id>');
     return 1;
   }
-  const record = action === 'show'
-    ? showConflict(projectDir, resourceType, resourceId)
-    : await resolveConflict(projectDir, resourceType, resourceId);
+  const custom = require('./customService').isServiceType(resourceType);
+  const services = custom ? require('../customServices') : null;
+  const record = custom
+    ? (action === 'show' ? services.showConflict(projectDir, resourceId) : services.resolveConflict(projectDir, resourceId))
+    : (action === 'show' ? showConflict(projectDir, resourceType, resourceId) : await resolveConflict(projectDir, resourceType, resourceId));
   if (flags.output === 'json') console.log(JSON.stringify(record, null, 2));
   else printRecord(record);
   if (action === 'resolve') log.info('The remote revision is now the base; run check, diff, and commit the merged worktree file.');

package/src/commands/conflicts.js

@@ -2,9 +2,10 @@
 
 const log = require('../logger');
 const { listConflicts } = require('../worktree');
+const { serviceConflicts } = require('../customServices');
 
 function conflicts(projectDir, _positional, flags = {}) {
-  const records = listConflicts(projectDir, { all: Boolean(flags.all) });
+  const records = [...listConflicts(projectDir, { all: Boolean(flags.all) }), ...serviceConflicts(projectDir, { all: Boolean(flags.all) })];
   if (flags.output === 'json') console.log(JSON.stringify(records, null, 2));
   else if (!records.length) log.ok('No unresolved DraftGo conflicts.');
   else for (const record of records) {

package/src/commands/context.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const log = require('../logger');
-const { collectContext, TASK_PROFILES } = require('../context');
+const { collectContext, compactContext, TASK_PROFILES } = require('../context');
 const { parseTimeout } = require('../timeout');
 
 function printUsage() {
@@ -17,7 +17,7 @@ async function contextCommand(projectDir, positional = [], flags = {}) {
   const result = await collectContext(projectDir, flags.task, {
     timeoutMs: parseTimeout(flags.timeout),
   });
-  console.log(JSON.stringify(result, null, 2));
+  console.log(JSON.stringify(flags.compact ? compactContext(result) : result, null, 2));
   return 0;
 }
 

package/src/commands/customService.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const fs = require('fs');
+const log = require('../logger');
+const services = require('../customServices');
+
+function ids(positional) { return positional.map(String).filter(Boolean); }
+const TYPE_ALIASES = new Set(['custom-services', 'custom-service', 'custom_services', 'custom_service', 'services', 'scripts', 'custom_scripts']);
+function isServiceType(value) {
+  return TYPE_ALIASES.has(String(value || '').toLowerCase());
+}
+function serviceIds(positional) {
+  const values = ids(positional);
+  if (isServiceType(values[0])) values.shift();
+  return values;
+}
+function output(flags, value) {
+  if (flags.output === 'json') console.log(JSON.stringify(value, null, 2));
+}
+
+async function checkout(projectDir, positional, flags = {}) {
+  const values = ids(positional);
+  if (!values.length) { log.err('Usage: draftgo checkout custom-services <id...>'); return 1; }
+  const result = await services.checkout(projectDir, values, { force: Boolean(flags.force) });
+  if (flags.output === 'json') output(flags, result);
+  else result.forEach((item) => log.ok(`custom service ${item.resource_id} -> ${item.local_path}`));
+  return 0;
+}
+
+async function commit(projectDir, positional, flags = {}) {
+  const values = ids(positional);
+  if (!values.length) { log.err('Usage: draftgo commit custom-services <id...>'); return 1; }
+  const result = await services.commit(projectDir, values);
+  if (flags.output === 'json') output(flags, result);
+  else result.forEach((item) => log.ok(`custom service ${item.resource_id}: ${item.status}`));
+  return 0;
+}
+
+async function diff(projectDir, positional, flags = {}) {
+  const id = positional[0];
+  if (!id) { log.err('Usage: draftgo diff custom-services <id>'); return 1; }
+  const result = services.diff(projectDir, id);
+  if (flags.output === 'json') output(flags, result);
+  else if (result.changed) process.stdout.write(result.output);
+  else log.dim(`custom service ${id}: no local changes`);
+  return 0;
+}
+
+async function validate(projectDir, positional, flags = {}) {
+  const id = serviceIds(positional)[0];
+  if (!id) { log.err('Usage: draftgo validate custom-services <id>'); return 1; }
+  const result = await services.validate(projectDir, id);
+  if (flags.output === 'json') output(flags, result); else log.ok(`custom service ${id}: ${result.validation_status}`);
+  return result.validation_status === 'passed' ? 0 : 1;
+}
+
+async function test(projectDir, positional, flags = {}) {
+  const id = serviceIds(positional)[0];
+  if (!id) { log.err('Usage: draftgo test custom-services <id> [--input <json-file>]'); return 1; }
+  let input = {};
+  if (flags.input) input = JSON.parse(fs.readFileSync(String(flags.input), 'utf8'));
+  const readJSON = (value) => value ? JSON.parse(fs.readFileSync(String(value), 'utf8')) : undefined;
+  const policy = String(flags['side-effect-policy'] || 'deny').toLowerCase();
+  if (!['deny', 'mock', 'live'].includes(policy)) throw new Error('--side-effect-policy must be deny, mock, or live.');
+  const result = await services.test(projectDir, id, input, { handler: flags.handler, headers: readJSON(flags.headers), user: readJSON(flags.user),
+    testWrite: Boolean(flags['test-write']), sideEffectPolicy: policy });
+  if (flags.output === 'json') output(flags, result);
+  else log[result.status === 'success' ? 'ok' : 'err'](`custom service ${id}: ${result.status}`);
+  return result.status === 'success' ? 0 : 1;
+}
+
+async function publish(projectDir, positional, flags = {}) {
+  const values = serviceIds(positional);
+  if (!values.length) { log.err('Usage: draftgo publish custom-services <id...>'); return 1; }
+  const result = await services.publish(projectDir, values);
+  if (flags.output === 'json') output(flags, result);
+  else values.forEach((id) => log.ok(`custom service ${id}: published`));
+  return 0;
+}
+
+module.exports = { checkout, commit, diff, validate, test, publish, serviceIds, isServiceType };

package/src/commands/deploy.js

@@ -11,7 +11,7 @@ async function deploy(projectDir, positional, flags = {}) {
   }
 
   log.step('deploy: validating checked-out content...');
-  const checkCode = check(projectDir, { strict: flags.strict });
+  const checkCode = await check(projectDir, { strict: flags.strict });
   if (checkCode !== 0) {
     log.err('Deploy stopped because local validation failed.');
     return checkCode;

package/src/commands/diff.js

@@ -9,6 +9,9 @@ function diff(projectDir, positional, flags = {}) {
     log.err('Usage: draftgo diff <pages|nav|docs> <id>');
     return 1;
   }
+  if (require('./customService').isServiceType(resourceType)) {
+    return require('./customService').diff(projectDir, [resourceId], flags);
+  }
   const result = diffResource(projectDir, resourceType, resourceId);
   if (flags.output === 'json') {
     console.log(JSON.stringify({ changed: result.changed, entry: result.entry, diff: result.output }, null, 2));

package/src/commands/help.js

@@ -16,7 +16,7 @@ function help() {
 DraftGo Next frontend baseline: React + Vite.
 Database pages may use native web technologies or bundled component libraries.
 MCP handles live discovery and structured resources; complete page, navigation,
-and document bodies use checkout/commit outside MCP context.
+document, and custom-service bodies use checkout/commit outside MCP context.
 The context command combines exact local Reference sections with live MCP data;
 it is a CLI orchestration command, not an MCP tool.
 
@@ -44,9 +44,19 @@ Usage:
                                     overlay local checkout state.
   draftgo checkout <type> <id...>  Download pages/nav/docs body + verified base.
                                     --force explicitly replaces local changes.
-  draftgo check                    Validate checked-out worktree/base files only.
+  draftgo check [custom-services <id...>]
+                                    Validate all checkouts or selected custom services.
+                                    --remote also compares remote hash/version.
   draftgo diff <type> <id>         Show checkout base versus local body.
   draftgo commit <type> <id...>    Validate and upload complete checked-out bodies.
+  draftgo refresh <type> <id...>   Safely refresh a clean checkout from the cloud.
+  draftgo validate custom-services <id>
+                                    Build and inspect the current cloud draft.
+  draftgo test custom-services <id> [--handler <selector>]
+                                    Run the cloud draft in the DraftGo Runner.
+  draftgo publish custom-services <id...>
+                                    Publish validated drafts atomically.
+  draftgo reconcile <type> <id...> Repair stale metadata only when local equals remote.
   draftgo conflicts                List unresolved conflicts; --all includes resolved.
   draftgo conflict show <type> <id>
                                     Show preserved base/local/remote paths.
@@ -54,10 +64,18 @@ Usage:
                                     Mark a merged worktree file ready against the
                                     preserved remote base; then check/diff/commit.
   draftgo verify-ui <url>          Run a deterministic browser smoke check.
+                                    Screenshots default to never.
+  draftgo clean [--dry-run|--yes]  Plan or remove registered tmp/artifacts only.
+  draftgo task <operation> [...]   Track sustained work in one authoritative Task.md.
+                                    Operations: create, list, show, add, claim,
+                                    start, complete, block, reopen, accept, finish,
+                                    and explicit legacy migrate.
 
   draftgo api <query>              Search the live API contract through MCP.
   draftgo api describe <operation_id>
                                     Describe one live API operation through MCP.
+  draftgo api call <operation_id> --input <json-file>
+                                    Call one described operation with UTF-8 JSON.
   draftgo delete <operation_id> [id]
                                     Confirm and call a live delete operation.
                                     Legacy <type> <id> works only when unambiguous.
@@ -82,7 +100,7 @@ Usage:
   draftgo -h | --help              Show this help.
 
 Resource types:
-  pages | nav/navigations | docs/articles
+  pages | nav/navigations | docs/articles | custom-services
 
 Important flags:
   --project <dir>          Operate on <dir> instead of the current directory.
@@ -106,17 +124,27 @@ Important flags:
                            content | project.
   --type <type>            (map) pages | nav/navigations | docs/articles.
   --strict                 Treat check warnings as failures.
+  --remote                 (check) Compare checkout hashes/versions with remote.
   --yes                    Skip supported confirmation prompts.
   --operation-id <id>      (delete) Select an operation explicitly.
-  --params <json>          (delete) Pass an API parameter object.
-  --input <file>           (delete) Read the parameter object from JSON.
+  --params <json>          (api call/delete) Pass an API parameter object.
+  --input <file>           (api call/delete) Read a UTF-8 JSON parameter object.
+  --handler <selector>     (custom-service test) route:METHOD:/path, event:name,
+                           scheduled:name, or a handler name.
+  --headers/--user <file>  (custom-service test) Read JSON test identity data.
+  --test-write             (custom-service test) Permit declared write testing.
+  --side-effect-policy <mode>
+                           (custom-service test) deny | mock | live; default deny.
   --delivery <mode>        (deploy) local | preview | deploy.
   --dry-run                (push) Show diffs without committing.
   --mobile-check <mode>    (verify-ui) auto | always | never.
   --token <mode>           (verify-ui) auto | never; auto appends the configured
                            SAT to same-origin URLs as the token query parameter.
-  --screenshot <mode>      (verify-ui) on-failure | always | never.
+  --screenshot <mode>      (verify-ui) on-failure | always | never; default never.
   --browser <name>         (verify-ui) chromium | chrome | msedge.
+  --browser-path <file>    (verify-ui) Explicit browser executable; environment
+                           fallback: DRAFTGO_BROWSER_PATH.
+  --resource <type:id>     (verify-ui) Compare local and remote content first.
   --selector <css>         (verify-ui) Require a visible key element.
   --width/--height <px>    (verify-ui) Override the default 390x844 viewport.
 
@@ -141,6 +169,9 @@ Examples:
   draftgo diff pages 42
   draftgo commit pages 42
   draftgo changelog add "Complete document management and role permissions"
+  draftgo task create "Personal growth" --original "Build a Notion-like system" \
+    --clarified "Build goals, habits, notes, and reviews" \
+    --expected-effect "Users manage personal growth in one workspace"
   draftgo deploy docs 7 --delivery preview
 `);
 }

package/src/commands/map.js

@@ -4,16 +4,17 @@ const fs = require('fs');
 const path = require('path');
 const log = require('../logger');
 const { loadProjectConfig } = require('../projectConfig');
-const { loadManifest, absolutePath } = require('../worktree/manifest');
-const { hashFile } = require('../worktree/streams');
 const { canonicalResourceType } = require('../worktree/types');
 const { TOOL_NAMES, openToolSession, callStructured } = require('../mcp/tools');
 const { allWithAbort } = require('../mcp/parallel');
+const { inspectRemoteCheckouts } = require('../worktree/status');
+const customServices = require('../customServices');
 
 const REMOTE_RESOURCE_TYPES = Object.freeze({
   pages: 'pages',
   navigations: 'navigations',
   docs: 'docs/articles',
+  custom_services: 'custom_services',
 });
 const DEFAULT_REMOTE_RESOURCE_TYPES = Object.freeze(Object.values(REMOTE_RESOURCE_TYPES));
 
@@ -42,6 +43,7 @@ function claimsMorePages(value) {
 }
 
 function normalizeMapResourceType(value) {
+  if (require('./customService').isServiceType(value)) return 'custom_services';
   return REMOTE_RESOURCE_TYPES[canonicalResourceType(value)];
 }
 
@@ -82,28 +84,18 @@ async function listRemoteResources(session, resourceTypes = DEFAULT_REMOTE_RESOU
   return groups.flat();
 }
 
-async function localCheckouts(projectDir) {
-  const manifest = loadManifest(projectDir);
-  const entries = [];
-  for (const entry of Object.values(manifest.entries)) {
-    const local = absolutePath(projectDir, entry.local_path);
-    let currentHash = null;
-    if (fs.existsSync(local)) currentHash = (await hashFile(local)).hash;
-    entries.push({
-      ...entry,
-      exists: currentHash !== null,
-      current_hash: currentHash,
-      changed: currentHash !== null && currentHash !== entry.base_hash,
-    });
-  }
-  return entries;
-}
-
 function legacyCaches(projectDir) {
   return ['pages', 'navigations', 'docs', 'db_meta', 'custom_scripts', 'aihub', 'roles', 'users', 'system_config']
     .filter((name) => fs.existsSync(path.join(projectDir, '.draftgo', name, 'index.json')));
 }
 
+function checkoutChanged(entry) {
+  if (entry.resource_type === 'custom_services') {
+    return ['local_modified', 'diverged', 'committed_unrecorded'].includes(entry.state);
+  }
+  return entry.local_hash !== null && entry.local_hash !== entry.base_hash;
+}
+
 async function mapCommand(projectDir, flags = {}) {
   const resourceTypes = requestedResourceTypes(flags);
   const config = loadProjectConfig(projectDir);
@@ -113,7 +105,20 @@ async function mapCommand(projectDir, flags = {}) {
       (options) => callStructured(session, TOOL_NAMES.projectOverview, {}, options),
       (options) => listRemoteResources(session, resourceTypes, options),
     ], options),
-    () => localCheckouts(projectDir),
+    async (options) => {
+      const [contentStatus, serviceStatus] = await Promise.all([inspectRemoteCheckouts(projectDir, {
+        config,
+        client: session.client,
+        tools: session.tools,
+        signal: options.signal,
+      }), customServices.inspectRemote(projectDir, { config, signal: options.signal })]);
+      return [...contentStatus, ...serviceStatus].map((entry) => ({
+        ...entry,
+        exists: entry.local_hash !== null,
+        current_hash: entry.local_hash,
+        changed: checkoutChanged(entry),
+      }));
+    },
   ]);
   const [overview, resources] = remote;
   const result = {
@@ -138,8 +143,11 @@ async function mapCommand(projectDir, flags = {}) {
   for (const [type, count] of [...counts.entries()].sort()) log.plain(`  ${type}: ${count}`);
   log.info(`Local checkouts: ${checkouts.length}`);
   for (const entry of checkouts) {
-    const state = !entry.exists ? 'missing' : entry.changed ? 'modified' : 'clean';
-    log.plain(`  ${entry.resource_type} ${entry.resource_id}: ${state} (${entry.local_path})`);
+    const state = entry.state || (!entry.exists ? 'missing' : entry.changed ? 'modified' : 'clean');
+    log.plain(`  ${entry.resource_type} ${entry.resource_id}: ${state}`
+      + ` local=${entry.local_hash || entry.current_hash || '-'} base=${entry.manifest_hash || entry.base_hash || '-'} remote=${entry.remote_hash || '-'} `
+      + `version=${entry.manifest_version ?? '-'}->${entry.remote_version ?? '-'} `
+      + `(${entry.local_path})`);
   }
   if (result.legacy_cache.detected.length) {
     log.warn(`Ignored legacy cache indexes: ${result.legacy_cache.detected.join(', ')}`);
@@ -152,3 +160,4 @@ module.exports.itemsFrom = itemsFrom;
 module.exports.normalizeMapResourceType = normalizeMapResourceType;
 module.exports.requestedResourceTypes = requestedResourceTypes;
 module.exports.listRemoteResources = listRemoteResources;
+module.exports.checkoutChanged = checkoutChanged;

package/src/commands/mcp.js

@@ -13,6 +13,20 @@ const {
 const { serveStdio } = require('../mcp/stdio');
 const { parseTimeout } = require('../timeout');
 
+function classifyMcpFailure(error) {
+  const message = String(error && error.message || error || '');
+  const code = error && error.code;
+  const status = error && error.status;
+  if (status === 401 || status === 403) return 'SAT authentication or authorization failed.';
+  if (/session|uninitialized|initialize first|not initialized/i.test(message)
+      || ['SESSION_EXPIRED', 'MCP_SESSION_EXPIRED', -32002].includes(code)) {
+    return 'The MCP session was lost or the server rejected the initialized state; check sticky sessions and service restarts.';
+  }
+  if (status >= 500) return 'The MCP service returned a server error; inspect the service request ID and logs.';
+  if (/tools\/call|tool/i.test(message)) return 'Tool invocation failed after protocol setup; inspect the tool contract and server handler.';
+  return 'Connection or MCP protocol negotiation failed.';
+}
+
 function targetArgs(positional, flags) {
   const values = positional.slice();
   if (flags.target) values.push(...String(flags.target).split(','));
@@ -87,19 +101,27 @@ function status(projectDir, positional = [], flags = {}) {
 
 async function test(projectDir, _positional = [], flags = {}) {
   let config;
+  const stages = [];
   try {
     config = loadProjectConfig(projectDir);
     const result = await testConnection(config, {
       timeoutMs: parseTimeout(flags.timeout),
+      onStage(stage, status) {
+        stages.push({ stage, status });
+        if (status === 'succeeded') log.ok(`MCP ${stage} succeeded.`);
+        else if (status === 'failed') log.err(`MCP ${stage} failed.`);
+        else log.step(`MCP ${stage}...`);
+      },
     });
-    log.ok('DraftGo MCP initialize succeeded.');
-    log.ok(`tools/list returned ${result.tools.length} tools.`);
-    log.ok(`tools/call succeeded: ${result.testedCalls.join(', ')}`);
+    log.ok(`MCP diagnostic completed: ${result.testedCalls.length} tools/call checks passed.`);
     log.dim(`  protocol: ${result.protocolVersion}`);
     return 0;
   } catch (error) {
     const token = config && String(config.token || config.sat || '');
     log.err(redactText(error && error.message ? error.message : error, [token]));
+    const last = stages[stages.length - 1];
+    if (last) log.info(`MCP diagnostic stopped at ${last.stage} (${last.status}).`);
+    log.info(classifyMcpFailure(error));
     return 1;
   }
 }
@@ -125,3 +147,4 @@ mcp.serve = serve;
 mcp.printUsage = printUsage;
 
 module.exports = mcp;
+module.exports.classifyMcpFailure = classifyMcpFailure;

package/src/commands/reconcile.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const log = require('../logger');
+const { reconcileResources } = require('../worktree');
+
+async function reconcile(projectDir, positional, flags = {}) {
+  const [resourceType, ...ids] = positional;
+  if (!resourceType || !ids.length) {
+    log.err('Usage: draftgo reconcile <pages|nav|docs> <id...>');
+    return 1;
+  }
+  if (require('./customService').isServiceType(resourceType)) {
+    const services = require('../customServices');
+    const states = await services.inspectRemote(projectDir);
+    const results = [];
+    for (const id of ids) {
+      const state = states.find((entry) => String(entry.resource_id) === String(id));
+      if (!state || state.state !== 'committed_unrecorded') throw new Error(`custom_services ${id} cannot be reconciled from state ${state?.state || 'missing'}.`);
+      await services.checkout(projectDir, [id], { force: true });
+      results.push({ resource_type: 'custom_services', resource_id: String(id), base_revision: state.remote_revision });
+    }
+    if (flags.output === 'json') console.log(JSON.stringify(results, null, 2));
+    else results.forEach((result) => log.ok(`Reconciled custom_services ${result.resource_id} -> ${result.base_revision}`));
+    return 0;
+  }
+  const results = await reconcileResources(projectDir, resourceType, ids);
+  if (flags.output === 'json') console.log(JSON.stringify(results, null, 2));
+  else for (const result of results) {
+    log.ok(`Reconciled ${result.resource_type} ${result.resource_id} -> ${result.base_version ?? result.base_revision}`);
+  }
+  return 0;
+}
+
+module.exports = reconcile;