@audienti/cli 0.1.145 → 0.2.0-exora.2

package/cli/sender-account-operations.mjs

@@ -0,0 +1,24 @@
+import {z} from 'zod';
+const text=(min,max)=>z.string().meta({minLength:min,maxLength:max});
+const uuid=z.string().uuid(),version=z.number().int().min(0).max(2147483646);
+const base={requestId:uuid,reason:text(1,2000).describe('Trimmed NFC; no controls including interior newlines or tabs. Does not authorize sending.')};
+const alias={provider:z.enum(['email','linkedin']),accountRef:text(1,200).regex(/^[A-Za-z0-9@._:+\/-]+$/),expectedAliasVersion:version};
+const identity=z.object({namespace:text(1,64).describe('Discovery namespace: trimmed and lowercased.'),accountId:text(1,256).describe('Trimmed printable ASCII provider identity; case-sensitive assertion, not verification.')}).strict();
+const actionType=z.enum(['email.send','linkedin.send']);
+const pageLimit=z.number().int().min(1).max(100).optional();
+const query=a=>{const q=new URLSearchParams(Object.entries(a).map(([k,v])=>[k,String(v)]));return q.size?'?'+q:'';};
+const path=a=>`/sender-accounts/${encodeURIComponent(a.senderAccountId)}`;
+const body=a=>Object.fromEntries(Object.entries(a).filter(([key])=>!['senderAccountId','actionType'].includes(key)));
+const opaque=z.string().trim().min(1).max(256).regex(/^[ -~]+$/);
+export const senderAccountOperations={
+ sender_activity_report:{schema:z.object({...base,senderAccountId:uuid,sourceEventId:opaque,namespace:identity.shape.namespace,occurredAt:z.iso.datetime({offset:true}),providerMessageId:opaque.nullable(),relatedAttemptId:uuid.nullable()}).strict(),method:'POST',path:a=>path(a)+'/activity',body},
+ sender_alias_get:{schema:z.object({provider:alias.provider,accountRef:alias.accountRef}).strict(),method:'GET',path:a=>'/sender-accounts/alias'+query(a),ownerOnly:true},
+ sender_accounts_list:{schema:z.object({cursor:uuid.optional(),limit:pageLimit}).strict(),method:'GET',path:a=>'/sender-accounts'+query(a)},
+ sender_account_get:{schema:z.object({senderAccountId:uuid,aliasesCursor:text(1,1024).optional(),aliasesLimit:pageLimit,historyCursor:uuid.optional(),historyLimit:pageLimit}).strict(),method:'GET',path:a=>path(a)+query(body(a))},
+ sender_account_register:{schema:z.object({...base,...alias,agentId:uuid,accountIdentity:identity}).strict(),method:'POST',path:()=>'/sender-accounts',ownerOnly:true},
+ sender_alias_bind:{schema:z.object({...base,...alias,senderAccountId:uuid,agentId:uuid}).strict(),method:'POST',path:a=>path(a)+'/aliases',body,ownerOnly:true},
+ sender_alias_unbind:{schema:z.object({...base,...alias,senderAccountId:uuid}).strict(),method:'POST',path:a=>path(a)+'/aliases/unbind',body,ownerOnly:true},
+ sender_account_state_set:{schema:z.object({...base,senderAccountId:uuid,expectedVersion:version,state:z.enum(['active','retired'])}).strict(),method:'POST',path:a=>path(a)+'/lifecycle',body,ownerOnly:true},
+ sender_automation_get:{schema:z.object({senderAccountId:uuid,actionType}).strict(),method:'GET',path:a=>path(a)+'/automation/'+encodeURIComponent(a.actionType)},
+ sender_automation_set:{schema:z.object({...base,senderAccountId:uuid,actionType,expectedVersion:version,enabled:z.boolean()}).strict(),method:'POST',path:a=>path(a)+'/automation/'+encodeURIComponent(a.actionType),body,ownerOnly:true},
+};

package/cli/sender-accounts.mjs

@@ -0,0 +1,23 @@
+import {senderAccountOperations} from './sender-account-operations.mjs';
+import {callOwnerAccountOperation} from './owner-account-client.mjs';
+import {readJsonFile} from './json-file.mjs';
+import {WorkspaceRequestError} from './workspaces.mjs';
+export async function callSenderAccounts(name,args,profilePath){
+ return callOwnerAccountOperation(senderAccountOperations[name],args,profilePath,'sender account');
+}
+export async function senderAccountsCli(args){
+ const flags={},positions=[];const known=['profile','file','cursor','limit','aliases-cursor','aliases-limit','history-cursor','history-limit','action-type','provider','account-ref'];
+ for(let i=0;i<args.length;i++){const arg=args[i];if(arg==='--json')continue;if(!arg.startsWith('--')){positions.push(arg);continue;}const key=arg.slice(2);if(!known.includes(key)||Object.hasOwn(flags,key)||!args[i+1]||args[i+1].startsWith('--'))throw Error('Unknown, repeated or incomplete sender option.');flags[key]=args[++i];}
+ if(positions[0]!=='sender'||positions[1]!=='accounts')throw Error('Use sender accounts list|get|alias|register|bind|unbind|state|automation.');
+ const automation=positions[2]==='automation',activity=positions[2]==='activity',nested=automation||activity,command=nested?`${positions[2]}-${positions[3]}`:positions[2];
+ const names={'activity-report':'sender_activity_report',alias:'sender_alias_get',list:'sender_accounts_list',get:'sender_account_get',register:'sender_account_register',bind:'sender_alias_bind',unbind:'sender_alias_unbind',state:'sender_account_state_set','automation-get':'sender_automation_get','automation-set':'sender_automation_set'};
+ const name=names[command];if(!name)throw Error('Unknown sender account command.');
+ const operation=senderAccountOperations[name],hasId=!['list','register','alias'].includes(command),expected=nested?5:hasId?4:3;if(positions.length!==expected)throw Error('Unexpected sender arguments.');
+ const allowed=['profile',...(operation.method==='POST'?['file']:command==='alias'?['provider','account-ref']:command==='list'?['cursor','limit']:command==='get'?['aliases-cursor','aliases-limit','history-cursor','history-limit']:[]),...(automation?['action-type']:[])];
+ if(Object.keys(flags).some(key=>!allowed.includes(key)))throw Error('Option does not apply to this sender command.');
+ let input={};if(operation.method==='POST'){if(!flags.file)throw Error('--file INPUT.json is required.');input=readJsonFile(flags.file,65536,'Sender input');if(!input||typeof input!=='object'||Array.isArray(input))throw Error('invalid_fields: input must be a JSON object.');if(Object.hasOwn(input,'senderAccountId')||Object.hasOwn(input,'actionType')||Object.hasOwn(input,'workspaceId'))throw Error('Path IDs and workspaceId are not allowed in the file.');}
+ if(command==='alias'){input.provider=flags.provider;input.accountRef=flags['account-ref'];}
+ if(hasId)input.senderAccountId=positions[nested?4:3];if(automation)input.actionType=flags['action-type'];
+ for(const key of ['cursor','limit','aliases-cursor','aliases-limit','history-cursor','history-limit'])if(flags[key]!==undefined){const field=key.replace(/-([a-z])/g,(_,c)=>c.toUpperCase());if(key.endsWith('limit')){if(!/^\d+$/.test(flags[key]))throw new WorkspaceRequestError(400,'invalid_fields','Page limit must be 1–100.');input[field]=Number(flags[key]);}else input[field]=flags[key];}
+ console.log(JSON.stringify(await callSenderAccounts(name,input,flags.profile??process.env.AUDIENTI_PROFILE)));
+}

package/cli/skills-mcp.mjs

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { helperContracts, SKILL_VERSION } from '../skills/audienti/scripts/contracts.mjs';
+import { runHelper } from '../skills/audienti/scripts/profile-helpers.mjs';
+import { skillArtifact, skillCatalog, skillDetails } from './skills.mjs';
+
+const annotations = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+const result = value => ({ content: [{ type: 'text', text: JSON.stringify(value) }], structuredContent: value });
+
+export function registerSkills(server) {
+  server.registerTool('skills_list', { description: 'List bundled agent skills and deterministic helpers. Local, no authentication or provider calls.', inputSchema: z.object({}).strict(), annotations }, async () => result(skillCatalog()));
+  server.registerTool('skills_show', { description: 'Read bundled skill instructions, references, version, digest and helper schemas.', inputSchema: z.object({ id: z.literal('audienti') }).strict(), annotations }, async ({ id }) => result(skillDetails(id)));
+  for (const [name, contract] of Object.entries(helperContracts)) {
+    server.registerTool(`skills_${name.replaceAll('-', '_')}`, {
+      description: contract.description,
+      inputSchema: z.fromJSONSchema(contract.inputSchema), outputSchema: z.fromJSONSchema(contract.outputSchema), annotations,
+    }, async input => {
+      try { return result(runHelper(name, input)); }
+      catch { return { isError: true, content: [{ type: 'text', text: 'Invalid helper input; inspect its bundled schema and the 1 MiB limit.' }] }; }
+    });
+  }
+  server.registerResource('audienti-skill', `audienti://skills/audienti/${SKILL_VERSION}`, {
+    description: 'Versioned public skill artifact: instructions, references, scripts and schemas. Reading it does not install or execute anything.', mimeType: 'application/json',
+  }, async uri => ({ contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(skillArtifact()) }] }));
+}

package/cli/skills.mjs

@@ -0,0 +1,56 @@
+import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { SKILL_VERSION, helperContracts } from '../skills/audienti/scripts/contracts.mjs';
+import { executeHelperFile } from '../skills/audienti/scripts/run.mjs';
+
+const root = new URL('../skills/audienti/', import.meta.url);
+const files = ['SKILL.md', 'references/profile-workflows.md', 'references/helpers.md', 'references/workflow-receipt.md', 'scripts/contracts.mjs', 'scripts/profile-helpers.mjs', 'scripts/run.mjs'];
+
+function readSkill(id = 'audienti') {
+  if (id !== 'audienti') throw new Error('Unknown bundled skill. Use skills list.');
+  const contents = files.map(path => ({ path, text: readFileSync(new URL(path, root), 'utf8') }));
+  const hash = createHash('sha256');
+  for (const file of contents) hash.update(`${file.path}\0${Buffer.byteLength(file.text)}\0`).update(file.text);
+  return { contents, details: {
+    id, version: SKILL_VERSION, digest: hash.digest('hex'),
+    description: 'Agent-owned profile research with deterministic local helpers and guarded CRM writes.',
+    instructions: contents[0].text,
+    references: contents.filter(file => file.path.startsWith('references/')),
+    helpers: Object.entries(helperContracts).map(([name, contract]) => ({ name, ...contract })),
+  } };
+}
+
+export function skillDetails(id = 'audienti') { return readSkill(id).details; }
+
+export function skillCatalog() {
+  const { instructions, references, ...entry } = skillDetails();
+  return { skills: [entry] };
+}
+
+export function skillArtifact(id = 'audienti') {
+  const { details, contents } = readSkill(id);
+  return { ...details, files: contents.map(({ path, text }) => ({ path, content: text })) };
+}
+
+export async function skillsCli(argv) {
+  const args = argv.slice(1), json = args.includes('--json');
+  const filtered = args.filter(value => value !== '--json');
+  if (args.filter(value => value === '--json').length > 1) throw new Error('Invalid skills options.');
+  if (filtered.length === 1 && ['--help', 'help'].includes(filtered[0])) {
+    process.stdout.write('Usage: audienti skills list | show audienti | helper NAME --file INPUT.json|- [--json]\nLocal skill instructions/helpers; no login, installation or provider calls.\n'); return;
+  }
+  if (filtered[0] === 'list' && filtered.length === 1) {
+    const catalog = skillCatalog();
+    process.stdout.write(json ? `${JSON.stringify(catalog)}\n` : catalog.skills.map(skill => `${skill.id}@${skill.version} — ${skill.description}\n`).join('')); return;
+  }
+  if (filtered[0] === 'show' && filtered.length === 2) {
+    const details = skillDetails(filtered[1]);
+    process.stdout.write(json ? `${JSON.stringify(details)}\n` : `${details.instructions}\n`); return;
+  }
+  if (filtered[0] === 'helper' && filtered.length === 4 && filtered[2] === '--file') {
+    try { process.stdout.write(`${JSON.stringify(executeHelperFile(filtered[1], filtered[3]))}\n`); }
+    catch { throw new Error('Skill helper failed. Inspect its schema and provide valid JSON of at most 1 MiB.'); }
+    return;
+  }
+  throw new Error('Usage: audienti skills list | show audienti | helper NAME --file INPUT.json|- [--json]');
+}

package/cli/suppression-operations.mjs

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+const uuid=z.string().uuid();
+const located={workspaceId:uuid.optional(),prospectId:uuid};
+const path=a=>`/workspaces/${a.workspaceId}/prospects/${a.prospectId}/suppression`;
+export const suppressionOperations={
+ workspace_prospect_suppression:{schema:z.object({...located,history:z.object({cursor:uuid.optional(),limit:z.number().int().min(1).max(100).optional()}).strict().optional()}).strict(),method:'GET',path:a=>{const q=new URLSearchParams();if(a.history?.cursor)q.set('historyCursor',a.history.cursor);if(a.history?.limit!==undefined)q.set('historyLimit',String(a.history.limit));return path(a)+(q.size?'?'+q:'');},scoped:true},
+ workspace_prospect_suppression_set:{schema:z.object({...located,kind:z.enum(['dnc','reject']),action:z.enum(['set','clear']),expectedVersion:z.number().int().nonnegative(),requestId:uuid,reason:z.string().optional()}).strict(),method:'POST',path,body:({workspaceId,prospectId,...body})=>body,scoped:true},
+};

package/cli/suppression.mjs

@@ -0,0 +1,12 @@
+import { callWorkspace, configuration } from './workspaces.mjs';
+export async function suppressionCli(args){
+ const flags={},positions=[];
+ const allowed=['workspace','profile','history-cursor','history-limit','kind','action','expected-version','request-id','reason'];
+ for(let i=0;i<args.length;i++){const arg=args[i];if(arg==='--json')continue;if(!arg.startsWith('--')){positions.push(arg);continue;}const key=arg.slice(2);if(!allowed.includes(key)||Object.hasOwn(flags,key)||args[i+1]===undefined||args[i+1].startsWith('--'))throw Error('Unknown, repeated or incomplete suppression option.');flags[key]=args[++i];}
+ if(positions.length!==4||positions[0]!=='prospects'||positions[1]!=='suppression'||!['get','set'].includes(positions[2]))throw Error('Use prospects suppression get|set ID --workspace ID.');
+ const read=positions[2]==='get';const valid=['workspace','profile',...(read?['history-cursor','history-limit']:['kind','action','expected-version','request-id','reason'])];if(Object.keys(flags).some(k=>!valid.includes(k)))throw Error('Option does not apply to this command.');
+ const input={workspaceId:flags.workspace,prospectId:positions[3]};
+ if(read)input.history={...(flags['history-cursor']===undefined?{}:{cursor:flags['history-cursor']}),...(flags['history-limit']===undefined?{}:{limit:Number(flags['history-limit'])})};
+ else Object.assign(input,{kind:flags.kind,action:flags.action,expectedVersion:flags['expected-version']===undefined?undefined:Number(flags['expected-version']),requestId:flags['request-id'],...(flags.reason===undefined?{}:{reason:flags.reason})});
+ console.log(JSON.stringify(await callWorkspace(read?'workspace_prospect_suppression':'workspace_prospect_suppression_set',input,configuration(flags.profile))));
+}

package/cli/tools-operations.mjs

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+const uuid = z.string().uuid(), workspace = { workspaceId: uuid.optional() };
+const root = a => `/workspaces/${a.workspaceId}/tools`;
+const key = z.string().regex(/^[a-z][a-z0-9_]{0,47}$/).refine(v => !['constructor','prototype'].includes(v));
+const instruction = z.string().trim().min(1).max(4000);
+const question = z.discriminatedUnion('type', [
+ z.object({type:z.literal('boolean'),instructions:instruction,criteria:z.object({true:instruction.optional(),false:instruction.optional()}).strict().optional()}).strict(),
+ z.object({type:z.literal('choice'),instructions:instruction,criteria:z.record(key,z.string().max(2000)).refine(v=>Object.keys(v).length>=1&&Object.keys(v).length<=32)}).strict(),
+ z.object({type:z.literal('score'),instructions:instruction,criteria:z.array(instruction).min(1).max(10)}).strict(),
+]);
+const page = { page:z.number().int().min(1).max(10000).optional(), paginationToken:z.string().min(1).max(4096).optional() };
+const postedLimit = z.enum(['24h','week','month']).optional();
+const contentInputs = {
+ 'posts.fetch':z.object({url:z.string().min(1).max(2048),topicId:uuid}).strict(),
+ 'posts.search':z.object({query:z.string().trim().min(1).max(500),topicId:uuid,postedLimit,...page,sortBy:z.enum(['relevance','date']).optional()}).strict(),
+ 'posts.comments':z.object({postId:uuid,...page}).strict(),
+ 'posts.reactions':z.object({postId:uuid,page:page.page}).strict(),
+ 'profiles.search':z.object({kind:z.enum(['person','company']).optional(),query:z.string().trim().min(1).max(500).optional(),title:z.string().trim().min(1).max(200).optional(),location:z.string().trim().min(1).max(200).optional(),geoId:z.string().regex(/^\d{1,20}$/).optional(),industryIds:z.array(z.string().regex(/^\d{1,20}$/)).max(20).optional(),keywordsCompany:z.string().trim().min(1).max(200).optional(),currentCompany:z.string().trim().min(1).max(1024).optional(),companySizes:z.array(z.enum(['1-10','11-50','51-200','201-500','501-1000','1001-5000','5001-10000','10001+'])).max(8).optional(),page:page.page}).strict(),
+ 'profiles.posts':z.object({profileId:uuid,topicId:uuid,postedLimit,...page}).strict(),
+};
+const contentOperations = Object.fromEntries(Object.entries(contentInputs).map(([tool,input])=>[`tools_${tool.replaceAll('.','_')}`,{tool,paid:true,schema:z.object({...workspace,requestId:uuid,input}).strict(),method:'POST',path:a=>root(a)+'/'+tool,body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000}]));
+const recordsRoot = (a,kind) => `/workspaces/${a.workspaceId}/${kind}`;
+const contactInputs = {
+ 'email.find':z.object({profileId:uuid,domain:z.string().trim().min(1).max(253),refresh:z.boolean().optional()}).strict(),
+ 'mobile.find':z.object({profileId:uuid,email:z.string().min(1).max(320).optional(),refresh:z.boolean().optional()}).strict(),
+};
+export const hostedToolOperations = {
+ ...Object.fromEntries(Object.entries(contactInputs).map(([tool,input])=>[`tools_${tool.replaceAll('.','_')}`,{tool,paid:true,limits:{cacheDays:7,maximumAttempts:tool==='email.find'?130:3},schema:z.object({...workspace,requestId:uuid,input}).strict(),method:'POST',path:a=>root(a)+'/'+tool,body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:60000}])),
+ tools_email_verify:{tool:'email.verify',paid:true,limits:{providerCalls:1,cacheDays:7},schema:z.object({...workspace,requestId:uuid,input:z.object({email:z.string().max(320),refresh:z.boolean().optional()}).strict()}).strict(),method:'POST',path:a=>root(a)+'/email.verify',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000},
+ ...contentOperations,
+ topics_create:{traced:true,schema:z.object({...workspace,requestId:uuid,name:z.string().trim().min(1).max(200),slug:z.string().max(200).optional(),description:z.string().max(4000).optional()}).strict(),method:'POST',path:a=>recordsRoot(a,'topics'),body:({workspaceId,...a})=>a,scoped:true},
+ ...Object.fromEntries(['topics','posts'].flatMap(kind=>[
+  [`${kind}_list`,{traced:true,schema:z.object({...workspace,cursor:uuid.optional(),...(kind==='posts'?{topicId:uuid.optional()}:{})}).strict(),method:'GET',path:a=>recordsRoot(a,kind)+'?'+new URLSearchParams(Object.fromEntries(Object.entries({cursor:a.cursor,topicId:a.topicId}).filter(([,v])=>v))),scoped:true}],
+  [`${kind}_get`,{traced:true,schema:z.object({...workspace,id:uuid}).strict(),method:'GET',path:a=>recordsRoot(a,kind)+'/'+a.id,scoped:true}],
+ ])),
+ tools_list:{schema:z.object(workspace).strict(),method:'GET',path:root,scoped:true},
+ tools_web_search:{tool:'web.search',paid:true,limits:{providerCalls:1,cacheHours:24},schema:z.object({...workspace,requestId:uuid,input:z.object({query:z.string().trim().min(1).max(1000),country:z.string().regex(/^[A-Za-z]{2}$/).optional(),language:z.string().regex(/^[a-z]{2}(?:-[A-Z]{2})?$/).optional(),page:z.number().int().min(1).max(100).optional(),limit:z.number().int().min(1).max(10).optional(),timeRange:z.enum(['day','week','month','year']).optional(),refresh:z.boolean().optional()}).strict()}).strict(),method:'POST',path:a=>root(a)+'/web.search',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000},
+ tools_web_fetch:{tool:'web.fetch',paid:true,limits:{providerCalls:3,resultCache:false},schema:z.object({...workspace,requestId:uuid,input:z.object({url:z.string().min(1).max(2048)}).strict()}).strict(),method:'POST',path:a=>root(a)+'/web.fetch',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:90000},
+ tools_proxy_sessions_create:{tool:'proxy.sessions.create',paid:true,limits:{maxSeconds:3600,concurrentWorkspaceConnections:32,meter:'upstream_tcp_payload_bytes'},schema:z.object({...workspace,requestId:uuid,input:z.object({ttlSeconds:z.number().int().min(60).max(3600).optional(),parentOperationId:uuid.optional()}).strict()}).strict(),method:'POST',path:a=>root(a)+'/proxy.sessions.create',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000},
+ tools_proxy_sessions_close:{schema:z.object({...workspace,operationId:uuid}).strict(),method:'POST',path:a=>root(a)+'/proxy.sessions.close',body:a=>({operationId:a.operationId}),scoped:true},
+ tools_decide:{tool:'decide',paid:true,schema:z.object({...workspace,requestId:uuid,input:z.object({state:z.union([z.string(),z.record(z.string(),z.unknown()),z.array(z.unknown())]),questions:z.record(key,question).refine(v=>Object.keys(v).length>=1&&Object.keys(v).length<=16)}).strict()}).strict(),method:'POST',path:a=>root(a)+'/decide',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000},
+ tools_profiles_fetch:{tool:'profiles.fetch',paid:true,schema:z.object({...workspace,requestId:uuid,input:z.object({url:z.string().min(1).max(1024),refresh:z.boolean().optional(),fields:z.array(z.enum(['name','headline','about','location','experience','currentPositions','education','skills','websites','photo','connections','followers','certifications','languages','industries','employeeCount','employeeCountRange','founded','specialities','locations'])).min(1).max(20).optional()}).strict()}).strict(),method:'POST',path:a=>root(a)+'/profiles.fetch',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000},
+ tools_runs_get:{schema:z.object({...workspace,operationId:uuid,attemptAfter:z.number().int().min(0).max(2147483647).optional(),entryAfter:uuid.optional()}).strict(),method:'GET',path:a=>root(a)+`/runs/${a.operationId}`+((a.attemptAfter!==undefined||a.entryAfter)?`?${new URLSearchParams({...a.attemptAfter!==undefined?{attemptAfter:String(a.attemptAfter)}:{},...a.entryAfter?{entryAfter:a.entryAfter}:{}})}`:''),scoped:true},
+ tools_runs_list:{schema:z.object({...workspace,cursor:uuid.optional()}).strict(),method:'GET',path:a=>root(a)+'/runs'+(a.cursor?`?cursor=${encodeURIComponent(a.cursor)}`:''),scoped:true},
+ tools_balance:{schema:z.object(workspace).strict(),method:'GET',path:a=>root(a)+'/balance',scoped:true},
+};
+
+hostedToolOperations.tools_profiles_search.description = 'Legacy external paid Profile search, not saved database search. Retrieves one fresh provider page. Reuse requestId after interruptions; a timeout may have consumed paid work. Inspect tools_runs_get rather than redispatching with a new ID.';
+// Compatibility aliases share server admission identity; response shape is explicit.
+const fetchDescriptor = hostedToolOperations.tools_profiles_fetch;
+const fetchInput = fetchDescriptor.schema.shape.input;
+hostedToolOperations.tools_profiles_enrich = {
+ ...fetchDescriptor, tool: 'profiles.enrich', description: 'Explicit paid Profile enrichment by URL or authorized saved Profile ID; eligible 30-day cache reuse is free and refresh forces paid admission. Returns operation plus current workspace Prospect/profile projection. Shares admission identity with profiles.fetch. Reuse requestId after interruptions; a timeout may have consumed paid work. Inspect tools_runs_get rather than redispatching with a new ID.', limits: { providerCalls: 1, normalizedBytes: 65536, cacheDays: 30 }, resultKey: 'operation', canonicalTool: 'profiles.fetch',
+ schema: fetchDescriptor.schema.extend({ input: z.union([fetchInput, fetchInput.omit({url:true}).extend({profileId:uuid}).strict()]) }),
+ path: a => root(a) + '/profiles.enrich',
+};
+hostedToolOperations.tools_profiles_discover = {
+ ...hostedToolOperations.tools_profiles_search, tool: 'profiles.discover', description: 'Explicit paid external Profile discovery. Same admission identity and result as legacy profiles.search. For saved workspace profiles use profile_list. Reuse requestId after interruptions; a timeout may have consumed paid work. Inspect tools_runs_get rather than redispatching with a new ID.', canonicalTool: 'profiles.search',
+ path: a => root(a) + '/profiles.discover',
+};
+export const paidToolOperations = Object.fromEntries(Object.entries(hostedToolOperations).filter(([,operation])=>operation.paid));
+export const paidToolByName = Object.fromEntries(Object.entries(paidToolOperations).map(([name,operation])=>[operation.tool,{name,...operation}]));
+export const isPaidToolOperation = name => Object.hasOwn(paidToolOperations,name);
+
+// Only known descriptor shape decides where a paid operation lives. Never infer
+// a nested operation for unrelated responses or let projection state mask billing.
+export const paidToolResult = (name, data) => {
+ const descriptor = paidToolOperations[name];
+ return descriptor?.resultKey ? data?.[descriptor.resultKey] : data;
+};

package/cli/tools.mjs

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { hostedToolOperations, paidToolByName, isPaidToolOperation, paidToolResult } from './tools-operations.mjs';
+import { parseArgs } from 'node:util';
+import { readJsonFile } from './json-file.mjs';
+import { callWorkspace, configuration } from './workspaces.mjs';
+const help = `Usage:
+  audienti tools list [--workspace UUID] [--json]
+  audienti tools proxy.sessions.close UUID [--workspace UUID]
+  audienti tools describe decide|email.verify|email.find|mobile.find|profiles.fetch|posts.fetch|posts.search|posts.comments|posts.reactions|profiles.posts|profiles.search|proxy.sessions.create|web.search|web.fetch
+  audienti tools decide|email.verify|email.find|mobile.find|profiles.fetch|posts.fetch|posts.search|posts.comments|posts.reactions|profiles.posts|profiles.search|proxy.sessions.create|web.search|web.fetch --input FILE|- --request-id UUID [--workspace UUID] [--json]
+  audienti tools runs get UUID [--attempt-after ORDINAL] [--entry-after UUID] | list [--cursor UUID]
+  audienti tools balance
+
+email.find and mobile.find may return running: poll tools runs get OPERATION_ID.
+Keep the same request ID after interruptions; never submit a new one to retry a purchase.
+
+web.search returns one selected result page; workspace cache lasts 24 hours (refresh=true bypasses it).
+web.fetch returns inert text/links through a bounded HTML waterfall. Each completed logical
+web result costs 0.1 credit ($1 per 1000); failed requests, cache hits and request replays are free.
+Uses the selected private profile/workspace. Supply --profile PATH when needed.
+email.verify accepts {email,refresh?}; it records provider deliverability evidence without establishing ownership or authorizing sending. It reuses workspace validation for seven days; refresh makes a configured paid validation. Cache and same-request replay are free.
+profiles.fetch accepts a person /in/ or company /company/ URL as {url,fields?,refresh?}; a complete saved profile is free for 30 days.
+Explicit refresh requires paid admission; the result includes saved profile/prospect IDs.
+Fields: name, headline, about, location, experience, currentPositions, education, skills,
+websites, photo, connections, followers, certifications, languages. Company-specific fields:
+industries, employeeCount, employeeCountRange, founded, specialities, locations.
+profiles.enrich accepts the same fields as profiles.fetch, using url or saved profileId.
+Its operation has the same admission identity as profiles.fetch; the Prospect projection is a current free read.
+profiles.discover is the clear external-search alias of profiles.search; profiles list searches saved workspace records.
+profiles.search accepts person filters or {kind:"company",query,companySizes?}; results are partial profiles.
+Use describe for exact fields. No implicit email lookup.
+decide accepts {state,questions}; question types: boolean, choice, score.
+Questions have instructions; choice requires named criteria; score criteria are ordered
+from level zero. State is text, an object or an array. At most 32 KiB, 16 questions,
+32 choices per question and 10 score levels. No provider credentials belong in input.
+The request ID must be saved and reused after a timeout or interruption; never create a
+new ID just to retry an uncertain operation. A rejected operation made no provider call;
+after fixing its cause (for example adding credits), use a new ID for new work. Results and diagnostics contain trace IDs.
+Example input: {"state":"Can we talk?","questions":{"interest":{"type":"boolean","instructions":"Does this express interest?"}}}
+JSON results go to stdout; failures go to stderr and exit nonzero.`;
+async function readStdin() {
+ const chunks=[];let size=0;
+ for await(const chunk of process.stdin){size+=chunk.length;if(size>32768)throw new Error('Tool input exceeds 32 KiB.');chunks.push(chunk);}
+ try{return JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(Buffer.concat(chunks)));}catch{throw new Error('Tool input must be valid UTF-8 JSON.');}
+}
+export async function toolsCli(argv) {
+ const {positionals,values}=parseArgs({args:argv.slice(1),allowPositionals:true,strict:true,options:{help:{type:'boolean',short:'h'},json:{type:'boolean'},input:{type:'string'},'request-id':{type:'string'},workspace:{type:'string'},profile:{type:'string'},cursor:{type:'string'},'attempt-after':{type:'string'},'entry-after':{type:'string'}}});
+ if(values.help||positionals.length===0){console.log(help);return;}
+ const [verb,sub,id]=positionals;
+ if(verb==='describe'&&Object.hasOwn(paidToolByName,sub)&&positionals.length===2){console.log(JSON.stringify({name:sub,version:'1',canonicalTool:paidToolByName[sub].canonicalTool??sub,responseOperationPath:paidToolByName[sub].resultKey??null,inputSchema:z.toJSONSchema(paidToolByName[sub].schema.shape.input),limits:paidToolByName[sub].limits??(sub==='decide'?{bytes:32768,depth:32,questions:16,choices:32,scoreLevels:10}:sub==='profiles.fetch'?{providerCalls:1,normalizedBytes:65536,cacheDays:30}:{providerCalls:1,resultCache:false}),retry:'Reuse the same requestId and authenticated principal after interruptions.'},null,values.json?undefined:2));return;}
+ let name,args={workspaceId:values.workspace};
+ if(verb==='list'&&positionals.length===1)name='tools_list';
+ else if(verb==='balance'&&positionals.length===1)name='tools_balance';
+ else if(verb==='runs'&&sub==='get'&&positionals.length===3){name='tools_runs_get';args.operationId=id;args.entryAfter=values['entry-after'];if(values['attempt-after']!==undefined)args.attemptAfter=Number(values['attempt-after']);}
+ else if(verb==='runs'&&sub==='list'&&positionals.length===2){name='tools_runs_list';args.cursor=values.cursor;}
+ else if(verb==='proxy.sessions.close'&&positionals.length===2){name='tools_proxy_sessions_close';args.operationId=sub;}
+ else if(Object.hasOwn(paidToolByName,verb)&&positionals.length===1){
+  if(!values.input||!values['request-id'])throw new Error(`${verb} requires --input FILE|- and --request-id UUID. Keep the request ID for retries.`);
+  name=paidToolByName[verb].name;args.requestId=values['request-id'];args.input=values.input==='-'?await readStdin():readJsonFile(values.input,32768,'Tool input');
+ }else throw new Error('Unknown tools command. Use audienti tools --help.');
+ try{
+  const result=await callWorkspace(name,args,configuration(values.profile));
+  const paidResult = paidToolResult(name,result?.data);
+  if(['failed','uncertain','rejected'].includes(paidResult?.status)){
+   process.stderr.write(JSON.stringify({error:{code:paidResult.error?.code??'tool_incomplete'},operationId:paidResult.operationId,requestId:args.requestId,billing:paidResult.billing,...(paidResult.result?.persistence?{result:paidResult.result}:{}),requestTraceId:result.requestTraceId,recovery:paidResult.status==='rejected'?'resolve_rejection_then_new_request_id':paidResult.result?.persistence?.recovery??'retry_same_request_id'})+'\n');process.exitCode=1;return;
+  }
+  console.log(JSON.stringify(result));
+ }catch(error){
+  if(isPaidToolOperation(name))process.stderr.write(`Retain request ID ${args.requestId}; retry with the same ID to inspect/recover this operation.\n`);
+  throw error;
+ }
+}

package/cli/work-execution-operations.mjs

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+const uuid=z.string().uuid(), time=z.iso.datetime({offset:true}), version=z.number().int().min(0).max(2147483646);
+const reason=z.string().meta({minLength:1,maxLength:2000,description:'Trimmed NFC reason, 1–2000 Unicode code points, no controls or unpaired surrogates.'});
+const opaque=z.string().trim().min(1).max(256).regex(/^[ -~]+$/);
+const unavailable=z.object({availability:z.literal('unavailable'),reason}).strict();
+const evidence=z.discriminatedUnion('kind',[
+ z.object({kind:z.literal('provider_report'),reference:opaque,observedAt:time}).strict(),
+ z.object({kind:z.literal('account_evidence'),evidenceId:uuid,observedAt:time}).strict(),
+ z.object({kind:z.literal('owner_confirmation'),observedAt:time}).strict(),
+ z.object({kind:z.literal('no_dispatch'),journalRef:opaque,sealed:z.literal(true)}).strict(),
+ z.object({kind:z.literal('transport_uncertain'),reference:opaque,observedAt:time}).strict(),
+]);
+const content=z.union([
+ z.object({subject:z.string().meta({minLength:1,maxLength:256}),body:z.string().meta({minLength:1,maxLength:20000})}).strict(),
+ z.object({body:z.string().meta({minLength:1,maxLength:8000})}).strict(),
+]);
+export const workExecutionResultSchema=z.discriminatedUnion('outcome',[
+ z.object({outcome:z.literal('succeeded'),actualContent:z.union([unavailable,z.object({availability:z.literal('available'),content}).strict()]),providerMessageId:z.union([unavailable,z.object({availability:z.literal('available'),value:opaque}).strict()]),effectAt:time.nullable(),evidence}).strict(),
+ z.object({outcome:z.literal('failed'),effect:z.literal('none'),evidence}).strict(),
+ z.object({outcome:z.literal('unknown'),effect:z.literal('possible'),evidence}).strict(),
+]);
+const location={workspaceId:uuid.optional(),planId:uuid,clientActionId:z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)};
+const path=a=>`/workspaces/${a.workspaceId}/work/${a.planId}/actions/${encodeURIComponent(a.clientActionId)}`;
+const body=({workspaceId,planId,clientActionId,attemptId,...rest})=>rest;
+export const workspaceExecutionOperations={
+ workspace_work_claim:{schema:z.object({...location,expectedRevision:z.number().int().positive(),requestId:uuid}).strict(),scoped:true,method:'POST',path:a=>`${path(a)}/claims`,body},
+ workspace_work_start:{schema:z.object({...location,claimId:uuid,requestId:uuid}).strict(),scoped:true,method:'POST',path:a=>`${path(a)}/start`,body},
+ workspace_work_attempt_get:{schema:z.object({...location,historyCursor:uuid.optional(),historyLimit:z.number().int().min(1).max(100).optional()}).strict(),scoped:true,method:'GET',path:a=>{const q=new URLSearchParams();for(const key of ['historyCursor','historyLimit'])if(a[key]!==undefined)q.set(key,String(a[key]));return `${path(a)}/attempt?${q}`;}},
+};
+export const narrowExecutionOperations={
+ work_claim_release:{schema:z.object({claimId:uuid,requestId:uuid,reason}).strict(),method:'POST',path:a=>`/work-execution/claims/${a.claimId}/release`,body:({claimId,...rest})=>rest},
+ work_attempt_lookup:{schema:z.object({claimId:uuid}).strict(),method:'GET',path:a=>`/work-execution/claims/${a.claimId}/attempt`},
+ work_result_report:{schema:z.object({attemptId:uuid,requestId:uuid,mode:z.enum(['report','correct']),expectedResultVersion:version,reason,result:workExecutionResultSchema}).strict(),method:'POST',path:a=>`/work-execution/attempts/${a.attemptId}/results`,body},
+};
+export const workExecutionOperations={...workspaceExecutionOperations,...narrowExecutionOperations};

package/cli/work-execution.mjs

@@ -0,0 +1,29 @@
+import { workExecutionOperations } from './work-execution-operations.mjs';
+import { callWorkspace, configuration } from './workspaces.mjs';
+import { callOwnerAccountOperation } from './owner-account-client.mjs';
+import { readJsonFile } from './json-file.mjs';
+export function callWorkExecution(name,args,profile=process.env.AUDIENTI_PROFILE) {
+ const operation=workExecutionOperations[name];if(!operation)throw Error('Unknown work execution operation.');
+ return operation.scoped?callWorkspace(name,args,configuration(profile)):callOwnerAccountOperation(operation,args,profile,'work execution');
+}
+export async function workExecutionCli(args) {
+ const flags={},positions=[];
+ for(let i=0;i<args.length;i++){
+  const arg=args[i];if(arg==='--json')continue;if(!arg.startsWith('--')){positions.push(arg);continue;}
+  const key=arg.slice(2);if(!['profile','workspace','action','claim','attempt','file','cursor','limit'].includes(key)||Object.hasOwn(flags,key)||!args[i+1]||args[i+1].startsWith('--'))throw Error('Unknown, repeated or incomplete execution option.');flags[key]=args[++i];
+ }
+ const command=positions[2],workspace=['claim','start','get'].includes(command),read=['get','lookup'].includes(command);
+ const names={claim:'workspace_work_claim',start:'workspace_work_start',get:'workspace_work_attempt_get',release:'work_claim_release',lookup:'work_attempt_lookup',report:'work_result_report'};
+ if(!names[command]||positions.length!==(workspace?4:3))throw Error('Use work execution claim|start|get PLAN, release|lookup --claim ID, or report --attempt ID.');
+ const allowed=['profile',...(workspace?['workspace','action']:command==='report'?['attempt']:['claim']),...(read?command==='get'?['cursor','limit']:[]:['file'])];
+ if(Object.keys(flags).some(key=>!allowed.includes(key)))throw Error('Option does not apply to this execution command.');
+ if(workspace&&!flags.action)throw Error('This command requires --action.');
+ if(!workspace&&!(command==='report'?flags.attempt:flags.claim))throw Error('Supply the claim or attempt ID.');
+ const input=read?{}:readJsonFile(flags.file,65536,'Work execution input');
+ if(!input||typeof input!=='object'||Array.isArray(input))throw Error('invalid_fields: input must be a JSON object.');
+ const paths=workspace?['workspaceId','planId','clientActionId']:command==='report'?['attemptId']:['claimId'];
+ if(paths.some(key=>Object.hasOwn(input,key)))throw Error('invalid_fields: path IDs come from positions and flags only.');
+ Object.assign(input,workspace?{planId:positions[3],clientActionId:flags.action,...(flags.workspace?{workspaceId:flags.workspace}:{})}:command==='report'?{attemptId:flags.attempt}:{claimId:flags.claim});
+ if(command==='get'){if(flags.cursor)input.historyCursor=flags.cursor;if(flags.limit)input.historyLimit=Number(flags.limit);}
+ console.log(JSON.stringify(await callWorkExecution(names[command],input,flags.profile)));
+}

package/cli/work-feedback-operations.mjs

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+const uuid = z.string().uuid(), version = z.number().int().positive();
+const actionId = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+const reason = z.string().meta({ minLength: 1, maxLength: 2000, description: 'Trimmed NFC reason, 1–2000 Unicode code points; interior controls (including tabs/newlines) and unpaired surrogates are rejected. Visible to workspace members.' });
+const location = { workspaceId: uuid.optional(), planId: uuid };
+const item = { ...location, reviewRequestId: uuid };
+const mutation = { ...item, expectedVersion: version, requestId: uuid, reason };
+const root = a => `/workspaces/${a.workspaceId}/work/${a.planId}/change-requests`;
+const detail = a => `${root(a)}/${a.reviewRequestId}`;
+const body = ({ workspaceId, planId, clientActionId, reviewRequestId, ...input }) => input;
+export const workFeedbackOperations = {
+ workspace_work_change_request: { schema: z.object({ ...location, clientActionId: actionId, expectedRevision: version, expectedApprovalVersion: z.number().int().nonnegative(), kind: z.enum(['revise','alternative']), reason, requestId: uuid }).strict(), method: 'POST', scoped: true, path: a => `/workspaces/${a.workspaceId}/work/${a.planId}/actions/${a.clientActionId}/change-requests`, body },
+ workspace_work_change_respond: { schema: z.object({ ...mutation, responseRevision: version, responseClientActionId: actionId }).strict().describe('Respond with the changed original for Revise, or a new replacement after removing the original. Skip always requires a new action ID. A response never approves the proposal.'), method: 'POST', scoped: true, path: a => `${detail(a)}/respond`, body },
+ workspace_work_change_withdraw: { schema: z.object(mutation).strict(), method: 'POST', scoped: true, path: a => `${detail(a)}/withdraw`, body },
+ workspace_work_change_get: { schema: z.object(item).strict(), method: 'GET', scoped: true, path: detail },
+ workspace_work_change_list: { schema: z.object({ ...location, page: z.object({ cursor: uuid.optional(), limit: z.number().int().min(1).max(100).optional() }).strict().optional(), status: z.enum(['open','responded','withdrawn','cancelled']).optional() }).strict(), method: 'GET', scoped: true, path: a => { const q = new URLSearchParams(); for (const [key,value] of Object.entries({ ...a.page, status:a.status })) if(value!==undefined)q.set(key,String(value)); return `${root(a)}?${q}`; } },
+};

package/cli/work-feedback.mjs

@@ -0,0 +1,18 @@
+import { callWorkspace, configuration } from './workspaces.mjs';
+import { readJsonFile } from './json-file.mjs';
+export async function workFeedbackCli(args) {
+ const flags={}, positions=[];
+ for(let i=0;i<args.length;i++) { const arg=args[i];if(arg==='--json')continue;if(!arg.startsWith('--')){positions.push(arg);continue;}const key=arg.slice(2);if(!['profile','workspace','file','action','change','cursor','limit','status'].includes(key)||Object.hasOwn(flags,key)||!args[i+1]||args[i+1].startsWith('--'))throw new Error('Unknown, repeated, or incomplete work changes option.');flags[key]=args[++i]; }
+ const [, , command, planId]=positions;
+ if(positions.length!==4||!['request','respond','withdraw','get','list'].includes(command))throw new Error('Use work changes request|respond|withdraw|get|list PLAN.');
+ const read=['get','list'].includes(command),specific=command==='request'?['action']:command==='list'?['cursor','limit','status']:['change'];
+ const allowed=['profile','workspace',...specific,...(read?[]:['file'])];
+ if(Object.keys(flags).some(key=>!allowed.includes(key)))throw new Error('Option does not apply to this work changes command.');
+ if(command==='request'&&!flags.action)throw new Error('Request requires --action.');
+ if(!['request','list'].includes(command)&&!flags.change)throw new Error('This command requires --change.');
+ const input=read?{}:readJsonFile(flags.file,65536,'Work change input');
+ if(['workspaceId','planId','clientActionId','reviewRequestId'].some(key=>Object.hasOwn(input,key)))throw new Error('invalid_fields: location IDs come from flags and position only.');
+ Object.assign(input,{planId,...(flags.workspace?{workspaceId:flags.workspace}:{}),...(flags.action?{clientActionId:flags.action}:{}),...(flags.change?{reviewRequestId:flags.change}:{})});
+ if(command==='list'){input.page={...(flags.cursor?{cursor:flags.cursor}:{}),...(flags.limit?{limit:Number(flags.limit)}:{})};if(flags.status!==undefined)input.status=flags.status;}
+ console.log(JSON.stringify(await callWorkspace(`workspace_work_change_${command}`,input,configuration(flags.profile))));
+}

package/cli/work-operations.mjs

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+const uuid = z.string().uuid(), version = z.number().int().nonnegative();
+const workspace = { workspaceId: uuid.optional() };
+const page = z.object({cursor: uuid.optional(), limit: z.number().int().min(1).max(100).optional()}).strict();
+const clientId = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+const accountRef = z.string().min(1).max(200).regex(/^[A-Za-z0-9@._:+\/-]+$/);
+const evidence = z.array(uuid).max(100);
+const commonAction = {clientActionId: clientId, reason: z.string().min(1), evidenceIds: evidence, replyToEvidenceId: uuid.optional()};
+const email = z.object({...commonAction, type:z.literal('email.send'), content:z.object({subject:z.string(),body:z.string()}).strict(),recipient:z.object({prospectId:uuid,email:z.string(),contactId:uuid.optional()}).strict(),sender:z.object({provider:z.literal('email'),accountRef,senderAccountId:uuid.optional()}).strict()}).strict();
+const linkedin = z.object({...commonAction,type:z.literal('linkedin.send'),content:z.object({body:z.string()}).strict(),recipient:z.object({prospectId:uuid,profileUrl:z.string(),contactId:uuid.optional()}).strict(),sender:z.object({provider:z.literal('linkedin'),accountRef,senderAccountId:uuid.optional()}).strict()}).strict();
+const cadence = z.object({clientActionId:clientId,afterClientActionId:clientId.nullable(),trigger:z.literal('reported_success').nullable(),at:z.string().nullable(),waitSeconds:z.number().int().min(0).max(7776000).nullable(),condition:z.literal('no_pending_reply').nullable()}).strict();
+const located = {...workspace,planId:uuid,clientActionId:clientId};
+const mutation = {...located,expectedRevision:z.number().int().positive(),requestId:uuid};
+const root = a => `/workspaces/${a.workspaceId}`;
+const plan = a => `${root(a)}/work/${a.planId}`;
+const action = a => `${plan(a)}/actions/${encodeURIComponent(a.clientActionId)}`;
+const omit = (a, keys) => Object.fromEntries(Object.entries(a).filter(([k])=>!keys.includes(k)));
+const body = a => omit(a,['workspaceId','planId','clientActionId']);
+const qs = values => { const p=new URLSearchParams(); for(const [k,v] of Object.entries(values)) if(v!==undefined)p.set(k,String(v));return p.toString(); };
+export const workOperations = {
+ workspace_work_action_plan_save: {schema:z.object({...workspace,planId:uuid.nullable(),prospectId:uuid,experimentId:uuid.nullable(),experimentRevision:z.number().int().positive().nullable(),expectedRevision:version,requestId:uuid,origin:z.discriminatedUnion('kind',[z.object({kind:z.literal('agent'),skill:z.object({id:z.string(),version:z.string()}).strict()}).strict(),z.object({kind:z.literal('human'),editReason:z.string()}).strict()]),rationale:z.string(),evidenceIds:evidence,actions:z.array(z.discriminatedUnion('type',[email,linkedin])).min(1).max(50),cadence:z.array(cadence).max(50)}).strict(), method:'POST',path:a=>`${root(a)}/action-plans`,body:a=>omit(a,['workspaceId']),scoped:true},
+ workspace_work_operator_list: {schema:z.object({...workspace,page:page.optional(),filter:z.object({state:z.enum(['open','cancelled','terminal','invalidated']).optional(),reviewStatus:z.enum(['awaiting_revision','invalidated','pending_review','approved','in_progress','reconciliation_required','completed','cancelled']).optional(),search:z.string().optional(),queue:z.enum(['review','blocked','activity']).optional()}).strict().optional()}).strict(),method:'GET',path:a=>`${root(a)}/operator/work?${qs({...a.page,...a.filter})}`,scoped:true},
+ workspace_work_operator_get: {schema:z.object({...workspace,planId:uuid,revision:z.number().int().positive().optional(),history:page.optional()}).strict(),method:'GET',path:a=>`${plan(a)}?${qs({revision:a.revision,historyCursor:a.history?.cursor,historyLimit:a.history?.limit})}`,scoped:true},
+ workspace_work_action_approve: {schema:z.object({...mutation,expectedApprovalVersion:version}).strict(),method:'POST',path:a=>`${action(a)}/approve`,body,scoped:true},
+ workspace_work_action_withdraw: {schema:z.object({...mutation,expectedApprovalVersion:z.number().int().positive(),reason:z.string().min(1)}).strict(),method:'POST',path:a=>`${action(a)}/withdraw`,body,scoped:true},
+ workspace_work_action_cancel: {schema:z.object({...mutation,reason:z.string().min(1)}).strict(),method:'POST',path:a=>`${action(a)}/cancel`,body,scoped:true},
+ workspace_work_eligibility_get: {schema:z.object(located).strict(),method:'GET',path:a=>`${action(a)}/eligibility`,scoped:true},
+};

package/cli/work.mjs

@@ -0,0 +1,27 @@
+import { callWorkspace, configuration } from './workspaces.mjs';
+import { readJsonFile } from './json-file.mjs';
+export async function workCli(args) {
+ const flags={}, position=[];
+ const allowed=['profile','workspace','file','request-id','plan-id','client-action-id','cursor','limit','history-cursor','history-limit','revision','state','review-status','queue','search'];
+ for(let i=0;i<args.length;i++) {
+  if(args[i]==='--json')continue;
+  if(!args[i].startsWith('--')){position.push(args[i]);continue;}
+  const key=args[i].slice(2);if(!allowed.includes(key)||Object.hasOwn(flags,key)||args[i+1]===undefined||args[i+1].startsWith('--'))throw new Error('Unknown, repeated, or incomplete work option.');flags[key]=args[++i];
+ }
+ const names={'work plan save':'workspace_work_action_plan_save','work list':'workspace_work_operator_list','work show':'workspace_work_operator_get','work approve':'workspace_work_action_approve','work withdraw-approval':'workspace_work_action_withdraw','work cancel':'workspace_work_action_cancel','work eligibility':'workspace_work_eligibility_get'};
+ const name=names[position.join(' ')];if(!name)throw new Error('Use work plan save, list, show, approve, withdraw-approval, cancel, or eligibility. Writes require --file INPUT.json.');
+ const read=['workspace_work_operator_list','workspace_work_operator_get','workspace_work_eligibility_get'].includes(name);
+ const input=read?{}:readJsonFile(flags.file,65536,'Work input');
+ for(const [flag,key] of [['workspace','workspaceId'],['request-id','requestId'],['plan-id','planId'],['client-action-id','clientActionId']])if(flags[flag]!==undefined)input[key]=flags[flag];
+ if(name==='workspace_work_operator_list'){
+  input.page={...(flags.cursor===undefined?{}:{cursor:flags.cursor}),...(flags.limit===undefined?{}:{limit:Number(flags.limit)})};
+  input.filter={};for(const [flag,key] of [['state','state'],['review-status','reviewStatus'],['search','search'],['queue','queue']])if(flags[flag]!==undefined)input.filter[key]=flags[flag];
+ } else if(name==='workspace_work_operator_get'){
+  if(flags.revision!==undefined)input.revision=Number(flags.revision);
+  input.history={...(flags['history-cursor']===undefined?{}:{cursor:flags['history-cursor']}),...(flags['history-limit']===undefined?{}:{limit:Number(flags['history-limit'])})};
+ }
+ const applicable=new Set(['profile','workspace','file','request-id','plan-id','client-action-id',...(name==='workspace_work_operator_list'?['cursor','limit','state','review-status','search','queue']:[]),...(name==='workspace_work_operator_get'?['revision','history-cursor','history-limit']:[])]);
+ if(Object.keys(flags).some(k=>!applicable.has(k)))throw new Error('Option does not apply to this work command.');
+ if(read&&flags.file!==undefined)throw new Error('Read commands do not accept --file.');
+ console.log(JSON.stringify(await callWorkspace(name,input,configuration(flags.profile))));
+}