newo 3.7.4 → 3.7.5

package/src/domain/strategies/sync/V2ProjectSyncStrategy.ts

@@ -40,6 +40,7 @@ import type {
 } from '../../../types.js';
 import type { LocalProjectData, LocalAgentData, LocalFlowData, LocalSkillData, ApiClientFactory } from './ProjectSyncStrategy.js';
 import fs from 'fs-extra';
+import path from 'path';
 import {
   listProjects,
   listAgents,
@@ -105,6 +106,14 @@ import yaml from 'js-yaml';
 import { patchYamlToPyyaml } from '../../../format/yaml-patch.js';
 import type { RunnerType, SkillParameter } from '../../../types.js';
 
+interface V2FlowSkillTarget {
+  projectIdn: string;
+  agentIdn: string;
+  flowIdn: string;
+  skillIdn: string;
+  skillData: SkillMetadata | undefined;
+}
+
 /**
  * V2ProjectSyncStrategy - same API, newo_v2 file layout
  */
@@ -684,7 +693,7 @@ export class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalPr
           const isLibrary = change.path.includes('/libraries/');
           const count = isLibrary
             ? await this.pushV2LibrarySkillUpdate(client, change, mapData, newHashes)
-            : await this.pushV2SkillUpdate(client, change, mapData, newHashes);
+            : await this.pushV2SkillUpdate(client, change, mapData, newHashes, customer.idn);
           result.updated += count;
         }
       } catch (error) {
@@ -1140,26 +1149,16 @@ export class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalPr
     client: AxiosInstance,
     change: ChangeItem<LocalProjectData>,
     mapData: ProjectMap,
-    newHashes: HashStore
+    newHashes: HashStore,
+    customerIdn: string
   ): Promise<number> {
-    // Parse V2 path to extract entity hierarchy
-    // Path: .../newo_customers/{cust}/{proj}/agents/{agent}/flows/{flow}/skills/{skillFile}
-    const pathParts = change.path.split('/');
-    const skillFileName = pathParts[pathParts.length - 1] || '';
-    const skillIdn = skillFileName.replace(/\.(nsl|nslg|jinja|guidance)$/, '');
-    // skills/ -> flow/ -> flows/ -> agent/ -> agents/ -> project/
-    const flowIdn = pathParts[pathParts.length - 3] || '';
-    const agentIdn = pathParts[pathParts.length - 5] || '';
-    const projectIdn = pathParts[pathParts.length - 7] || '';
-
-    // Look up skill in map
-    const projectData = mapData.projects[projectIdn];
-    const agentData = projectData?.agents[agentIdn];
-    const flowData = agentData?.flows[flowIdn];
-    const skillData = flowData?.skills[skillIdn];
+    const target =
+      await this.resolveV2SkillTargetForScriptPath(customerIdn, change.path, mapData) ||
+      this.resolveV2SkillTargetFromCanonicalPath(change.path, mapData);
+    const skillData = target?.skillData;
 
-    if (!skillData) {
-      throw new Error(`Skill ${skillIdn} not found in project map (path: ${change.path})`);
+    if (!target || !skillData) {
+      throw new Error(`Skill not found in project map (path: ${change.path})`);
     }
 
     // Read updated script content
@@ -1178,10 +1177,92 @@ export class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalPr
     });
 
     newHashes[change.path] = sha256(content);
-    this.logger.info(`[newo_v2] Pushed: ${skillIdn}`);
+    this.logger.info(`[newo_v2] Pushed: ${target.skillIdn}`);
     return 1;
   }
 
+  private normalizePathForComparison(filePath: string): string {
+    return path.resolve(filePath).replace(/\\/g, '/');
+  }
+
+  private async resolveV2SkillTargetForScriptPath(
+    customerIdn: string,
+    scriptPath: string,
+    mapData: ProjectMap
+  ): Promise<V2FlowSkillTarget | null> {
+    const normalizedScriptPath = this.normalizePathForComparison(scriptPath);
+
+    for (const [projectIdn, projectData] of Object.entries(mapData.projects)) {
+      for (const [agentIdn, agentData] of Object.entries(projectData.agents)) {
+        for (const [flowIdn, flowData] of Object.entries(agentData.flows)) {
+          const flowYamlPath = v2FlowYamlPath(customerIdn, projectIdn, agentIdn, flowIdn);
+          if (!(await fs.pathExists(flowYamlPath))) {
+            continue;
+          }
+
+          let flowDef;
+          try {
+            flowDef = await parseV2FlowYaml(flowYamlPath);
+          } catch {
+            continue;
+          }
+
+          for (const skill of flowDef.skills || []) {
+            const runnerType = this.normalizeRunnerType(skill.runner_type || flowData.skills[skill.idn]?.runner_type);
+            const resolvedScriptPath = await this.resolveV2FlowSkillScriptPath(
+              customerIdn,
+              projectIdn,
+              agentIdn,
+              flowIdn,
+              skill.idn,
+              runnerType,
+              skill.prompt_script
+            );
+
+            if (this.normalizePathForComparison(resolvedScriptPath) === normalizedScriptPath) {
+              return {
+                projectIdn,
+                agentIdn,
+                flowIdn,
+                skillIdn: skill.idn,
+                skillData: flowData.skills[skill.idn]
+              };
+            }
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
+  private resolveV2SkillTargetFromCanonicalPath(
+    scriptPath: string,
+    mapData: ProjectMap
+  ): V2FlowSkillTarget | null {
+    // Parse canonical V2 path:
+    // .../newo_customers/{cust}/{proj}/agents/{agent}/flows/{flow}/skills/{skillFile}
+    const pathParts = scriptPath.split('/');
+    const skillFileName = pathParts[pathParts.length - 1] || '';
+    const skillIdn = skillFileName.replace(/\.(nsl|nslg|jinja|guidance)$/, '');
+    // skills/ -> flow/ -> flows/ -> agent/ -> agents/ -> project/
+    const flowIdn = pathParts[pathParts.length - 3] || '';
+    const agentIdn = pathParts[pathParts.length - 5] || '';
+    const projectIdn = pathParts[pathParts.length - 7] || '';
+
+    const projectData = mapData.projects[projectIdn];
+    const agentData = projectData?.agents[agentIdn];
+    const flowData = agentData?.flows[flowIdn];
+
+    return {
+      projectIdn,
+      agentIdn,
+      flowIdn,
+      skillIdn,
+      skillData: flowData?.skills[skillIdn]
+    };
+  }
+
   /**
    * Push a V2 library skill update
    * Path: .../newo_customers/{cust}/{proj}/libraries/{lib}/skills/{skillFile}

package/src/sandbox/chat.ts

@@ -23,7 +23,17 @@ import type {
 const SANDBOX_INTEGRATION_IDN = 'sandbox';
 const DEFAULT_TIMEZONE = 'America/Los_Angeles';
 const POLL_INTERVAL_MS = 1000; // 1 second
-const MAX_POLL_ATTEMPTS = 60; // Max 60 seconds wait
+const DEFAULT_TIMEOUT_MS = 60_000; // Default max wait for agent response
+
+/**
+ * Options for selecting which connector to chat through
+ */
+export interface ConnectorSelectionOptions {
+  /** Integration IDN to search connectors in (default: 'sandbox') */
+  integrationIdn?: string;
+  /** Exact connector_idn to use; when omitted, the first running connector is used */
+  connectorIdn?: string;
+}
 
 /**
  * Generate a random external ID for chat session
@@ -41,41 +51,81 @@ function generatePersonaName(): string {
 }
 
 /**
- * Find a sandbox connector from the customer's connectors list
+ * List running connectors of an integration (default: sandbox).
+ * Used by `newo sandbox --list-connectors` and connector selection.
  */
-export async function findSandboxConnector(client: AxiosInstance, verbose: boolean = false): Promise<Connector | null> {
-  if (verbose) console.log('🔍 Searching for sandbox integration...');
-
-  // First, get all integrations to find the sandbox integration
+export async function listRunningSandboxConnectors(
+  client: AxiosInstance,
+  integrationIdn: string = SANDBOX_INTEGRATION_IDN
+): Promise<Connector[]> {
   const integrations = await listIntegrations(client);
-  const sandboxIntegration = integrations.find(i => i.idn === SANDBOX_INTEGRATION_IDN);
+  const integration = integrations.find(i => i.idn === integrationIdn);
 
-  if (!sandboxIntegration) {
-    if (verbose) console.log('❌ Sandbox integration not found');
-    return null;
+  if (!integration) {
+    throw new Error(
+      `Integration '${integrationIdn}' not found. Available integrations: ${integrations.map(i => i.idn).join(', ') || '(none)'}`
+    );
   }
 
-  if (verbose) console.log(`✓ Found sandbox integration: ${sandboxIntegration.id}`);
+  const connectors = await listConnectors(client, integration.id);
+  return connectors.filter(c => c.status === 'running');
+}
 
-  // Now get connectors for the sandbox integration
-  if (verbose) console.log('🔍 Searching for sandbox connectors...');
-  const connectors = await listConnectors(client, sandboxIntegration.id);
-  const sandboxConnectors = connectors.filter(c => c.status === 'running');
+/**
+ * Find a sandbox connector from the customer's connectors list.
+ *
+ * Without options, preserves legacy behavior: first running connector of the
+ * 'sandbox' integration. With options.connectorIdn, selects that exact
+ * connector and throws a descriptive error (listing available connectors)
+ * when it is not found or not running.
+ */
+export async function findSandboxConnector(
+  client: AxiosInstance,
+  verbose: boolean = false,
+  options: ConnectorSelectionOptions = {}
+): Promise<Connector | null> {
+  const integrationIdn = options.integrationIdn || SANDBOX_INTEGRATION_IDN;
+
+  if (verbose) console.log(`🔍 Searching for ${integrationIdn} integration...`);
+
+  let runningConnectors: Connector[];
+  try {
+    runningConnectors = await listRunningSandboxConnectors(client, integrationIdn);
+  } catch (error) {
+    if (options.connectorIdn) throw error;
+    if (verbose) console.log(`❌ ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
 
-  if (sandboxConnectors.length === 0) {
-    if (verbose) console.log('❌ No running sandbox connectors found');
+  if (runningConnectors.length === 0) {
+    if (options.connectorIdn) {
+      throw new Error(`No running connectors found in integration '${integrationIdn}'`);
+    }
+    if (verbose) console.log(`❌ No running ${integrationIdn} connectors found`);
     return null;
   }
 
+  if (options.connectorIdn) {
+    const match = runningConnectors.find(c => c.connector_idn === options.connectorIdn);
+    if (!match) {
+      const available = runningConnectors.map(c => c.connector_idn).join(', ');
+      throw new Error(
+        `Connector '${options.connectorIdn}' not found among running connectors of integration '${integrationIdn}'. Available: ${available}`
+      );
+    }
+    if (verbose) console.log(`✓ Using connector: ${match.connector_idn}`);
+    return match;
+  }
+
   if (verbose) {
-    console.log(`✓ Found ${sandboxConnectors.length} running sandbox connector(s)`);
-    const firstConnector = sandboxConnectors[0];
+    console.log(`✓ Found ${runningConnectors.length} running ${integrationIdn} connector(s)`);
+    const firstConnector = runningConnectors[0];
     if (firstConnector) {
       console.log(`  Using: ${firstConnector.connector_idn}`);
     }
   }
 
-  return sandboxConnectors[0] || null;
+  return runningConnectors[0] || null;
 }
 
 /**
@@ -105,7 +155,7 @@ export async function createChatSession(
   const actorResponse = await createActor(client, personaResponse.id, {
     name: personaName,
     external_id: externalId,
-    integration_idn: SANDBOX_INTEGRATION_IDN,
+    integration_idn: connector.integration_idn || SANDBOX_INTEGRATION_IDN,
     connector_idn: connector.connector_idn,
     time_zone_identifier: DEFAULT_TIMEZONE
   });
@@ -132,7 +182,10 @@ export async function sendMessage(
   text: string,
   verbose: boolean = false
 ): Promise<Date> {
-  if (verbose) console.log(`💬 Sending message: "${text}"`);
+  if (verbose) {
+    const preview = text.length > 200 ? `${text.slice(0, 200)}… (${text.length} chars)` : text;
+    console.log(`💬 Sending message: "${preview}"`);
+  }
 
   const sentAt = new Date();
 
@@ -146,6 +199,17 @@ export async function sendMessage(
   return sentAt;
 }
 
+/**
+ * Parse an act datetime that may lack timezone info (assume UTC)
+ */
+function parseActDatetimeMs(datetime: string): number {
+  let d = datetime;
+  if (!d.endsWith('Z') && !d.includes('+') && !d.includes('-', 10)) {
+    d = d + 'Z';
+  }
+  return new Date(d).getTime();
+}
+
 /**
  * Poll for new conversation acts (messages and debug info)
  * Continues polling until we get an agent response, not just any new message
@@ -154,20 +218,23 @@ export async function pollForResponse(
   client: AxiosInstance,
   session: SandboxChatSession,
   messageSentAt: Date | null = null,
-  verbose: boolean = false
-): Promise<{ acts: ConversationAct[]; agentPersonaId: string | null }> {
+  verbose: boolean = false,
+  timeoutMs: number = DEFAULT_TIMEOUT_MS
+): Promise<{ acts: ConversationAct[]; agentPersonaId: string | null; userAct: ConversationAct | null }> {
   let attempts = 0;
   let agentPersonaId = session.agent_persona_id;
+  let userAct: ConversationAct | null = null;
+  const maxPollAttempts = Math.max(1, Math.ceil(timeoutMs / POLL_INTERVAL_MS));
 
-  if (verbose) console.log('⏳ Waiting for agent response...');
+  if (verbose) console.log(`⏳ Waiting for agent response (timeout: ${Math.round(timeoutMs / 1000)}s)...`);
 
   // Add small delay before first poll to allow message to be processed
   await new Promise(resolve => setTimeout(resolve, 500));
 
-  while (attempts < MAX_POLL_ATTEMPTS) {
+  while (attempts < maxPollAttempts) {
     try {
       if (verbose && attempts % 5 === 0) {
-        console.log(`  [Poll attempt ${attempts + 1}/${MAX_POLL_ATTEMPTS}] Checking for messages...`);
+        console.log(`  [Poll attempt ${attempts + 1}/${maxPollAttempts}] Checking for messages...`);
       }
 
       // Use Chat History API instead of acts API (doesn't require account_id)
@@ -221,6 +288,16 @@ export async function pollForResponse(
           }
         }
 
+        // Track the user act of our sent message (newest non-agent act at/after sentAt).
+        // Its external_event_id is the correlation key for `newo logs --event-id`.
+        for (const act of convertedActs) {
+          if (act.is_agent) continue;
+          if (messageSentAt && parseActDatetimeMs(act.datetime) - messageSentAt.getTime() <= -100) continue;
+          if (!userAct || parseActDatetimeMs(act.datetime) >= parseActDatetimeMs(userAct.datetime)) {
+            userAct = act;
+          }
+        }
+
         // Filter for agent messages that came AFTER our message was sent
         const agentMessages = convertedActs.filter(act => {
           if (!act.is_agent) return false;
@@ -262,7 +339,7 @@ export async function pollForResponse(
           // Return ONLY the single newest agent message (first one, since API returns newest first)
           const latestAgentMessage = agentMessages[0];
           if (latestAgentMessage) {
-            return { acts: [latestAgentMessage], agentPersonaId };
+            return { acts: [latestAgentMessage], agentPersonaId, userAct };
           }
         } else if (verbose && attempts % 10 === 0) {
           console.log(`  No new agent messages yet (checked ${response.items.length} total messages, sentAt: ${messageSentAt?.toISOString()}), continuing...`);
@@ -280,7 +357,7 @@ export async function pollForResponse(
   }
 
   if (verbose) console.log('⏱️  Timeout waiting for response');
-  return { acts: [], agentPersonaId };
+  return { acts: [], agentPersonaId, userAct };
 }
 
 /**

package/src/sync/remote-skill.ts

@@ -0,0 +1,92 @@
+/**
+ * Remote skill resolution by IDN path (project/agent/flow/skill).
+ *
+ * Used by `newo get-skill` and `newo update-skill` to address a single skill
+ * on the platform without requiring a pulled local workspace.
+ */
+import type { AxiosInstance } from 'axios';
+import { listProjects, listAgents, listFlowSkills, getSkill } from '../api.js';
+import type { ProjectMeta, Agent, Flow, Skill } from '../types.js';
+
+export interface RemoteSkillPath {
+  projectIdn: string;
+  agentIdn: string;
+  flowIdn: string;
+  skillIdn: string;
+}
+
+export interface ResolvedRemoteSkill {
+  project: ProjectMeta;
+  agent: Agent;
+  flow: Flow;
+  skill: Skill;
+}
+
+/**
+ * Resolve a skill on the platform by its IDN path.
+ * Throws descriptive errors listing available IDNs at the failing level.
+ */
+export async function resolveRemoteSkill(
+  client: AxiosInstance,
+  path: RemoteSkillPath
+): Promise<ResolvedRemoteSkill> {
+  const projects = await listProjects(client);
+  const project = projects.find(p => p.idn === path.projectIdn);
+  if (!project) {
+    throw new Error(
+      `Project '${path.projectIdn}' not found. Available projects: ${projects.map(p => p.idn).join(', ') || '(none)'}`
+    );
+  }
+
+  const agents = await listAgents(client, project.id);
+  const agent = agents.find(a => a.idn === path.agentIdn);
+  if (!agent) {
+    throw new Error(
+      `Agent '${path.agentIdn}' not found in project '${path.projectIdn}'. Available agents: ${agents.map(a => a.idn).join(', ') || '(none)'}`
+    );
+  }
+
+  const flows = agent.flows || [];
+  const flow = flows.find(f => f.idn === path.flowIdn);
+  if (!flow) {
+    throw new Error(
+      `Flow '${path.flowIdn}' not found in agent '${path.agentIdn}'. Available flows: ${flows.map(f => f.idn).join(', ') || '(none)'}`
+    );
+  }
+
+  const skills = await listFlowSkills(client, flow.id);
+  const skillStub = skills.find(s => s.idn === path.skillIdn);
+  if (!skillStub) {
+    throw new Error(
+      `Skill '${path.skillIdn}' not found in flow '${path.flowIdn}'. Available skills: ${skills.map(s => s.idn).join(', ') || '(none)'}`
+    );
+  }
+
+  // The flow-skills list endpoint already returns full skills including
+  // prompt_script (pull relies on this). Only fall back to the by-id
+  // endpoint when prompt_script is absent — and tolerate a 404 there,
+  // since /api/v1/designer/skills/{id} is not available on all accounts.
+  let skill = skillStub;
+  if (skill.prompt_script === undefined || skill.prompt_script === null) {
+    try {
+      skill = await getSkill(client, skillStub.id);
+    } catch {
+      skill = skillStub;
+    }
+  }
+
+  return { project, agent, flow, skill };
+}
+
+/**
+ * Parse a `--model provider_idn/model_idn` flag value
+ */
+export function parseModelFlag(value: string): { provider_idn: string; model_idn: string } {
+  const parts = value.split('/');
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new Error(
+      `Invalid --model value '${value}'. Expected format: <provider_idn>/<model_idn> (e.g. openai/gpt4o)`
+    );
+  }
+  return { provider_idn: parts[0], model_idn: parts[1] };
+}